氛围编码法：通过对话进行编码

The Vibe-Coding Approach: Code by Conversation

在 Vibe 编码中，您可以利用强大的 LLM 作为编码伙伴，让它们处理繁重的代码生成工作，以便您可以专注于更高层次的目标。正如《商业内幕》的一篇总结文章所说，Vibe 编码“意味着使用 AI 工具……来完成繁重的编码工作，从而快速构建软件”。正如英伟达 CEO 黄仁勋所说，得益于 AI，“最热门的新型编程语言”是英语，而不是 Java 或 Python。你无需手动输入每个函数和 bug 修复代码，而是用自然语言与 AI 交互——勾勒功能草图、查看建议，并根据 AI 的输出进行迭代。

In vibe coding, you leverage powerful LLMs as coding partners, letting them handle the heavy lifting of code generation so you can focus on higher-level goals. As one Business Insider summary puts it, vibe coding “means using AI tools...for the heavy lifting in coding to quickly build software.” As NVIDIA’s CEO Jensen Huang says, thanks to AI, “the hottest new programming language” is English, not Java or Python. Instead of manually typing out every function and bug fix, you interact with the AI in natural language—sketching out features, reviewing suggestions, and iterating based on the AI’s output.

这种方法标志着从传统编程到人工智能辅助开发的巨大转变。传统编码需要精心规划、语法精确，而且往往需要耗费大量精力进行调试。Vibe 编码则颠覆了这一模式：“这根本算不上编码——我只是看到一些东西，说一些东西，运行一些东西，复制粘贴一些东西，而且大部分都能正常运行，”Karpathy 在接受Business Insider采访时打趣道，并强调了人工智能如何能够以最小的人工干预将高级指令转化为可运行的代码。

This approach represents a dramatic shift from traditional programming to AI-assisted development. Conventional coding demands careful planning, syntax precision, and often painstaking debugging. Vibe coding flips that script: “It’s not really coding—I just see stuff, say stuff, run stuff, and copy-paste stuff, and it mostly works,” Karpathy quipped to Business Insider, highlighting how AI can turn high-level instructions into working code with minimal manual effort.

开发者们正从编写详细的计算机指令转向借助人工智能来协调最终结果。例如，Karpathy 描述了他如何通过不断接受人工智能的建议来构建一个 Web 应用：“我总是‘全部接受’，不再查看差异……遇到错误信息时，我直接复制粘贴……有时 LLM 无法修复 bug，所以我只能想办法绕过它，或者请求一些随机的修改，直到问题消失。” 代码的“增长”超过了他通常自己编写的规模，但通过迭代的提示和修复，项目很快就能完成。本质上，Vibe 编码将编码视为与 AI 结对程序员的互动对话，而不是独自苦苦钻研语法和堆栈跟踪。其目标是速度和探索——以最小的阻力获得可行的解决方案。

Developers move from writing detailed instructions for computers to orchestrating outcomes with the help of AI. As an example, Karpathy describes building a web app by continually accepting the AI’s suggestions: “I ‘Accept All’ always, I don’t read the diffs anymore.…When I get error messages, I just copy paste them in.…Sometimes the LLMs can’t fix a bug so I just work around it or ask for random changes until it goes away.” The code “grows” beyond what he’d normally write himself, yet the project comes together quickly through iterative prompting and fixing. Essentially, vibe coding treats coding as an interactive conversation with your AI pair programmer rather than as a solo slog through syntax and stack traces. The goal is speed and exploration—to get a working solution with minimal friction.

多种趋势的融合促成了氛围编码的实现。首先，现代人工智能编码助手（例如OpenAI 的法典，ChatGPT，Anthropic 的Claude 等程序员在生成和纠错代码方面已经变得异常出色。在同一篇文章中，Karpathy 指出，这“之所以成为可能，是因为这些高级编程语言（LLM）……变得太强大了”——它们已经吸收了大量的 GitHub 代码，能够为许多任务生成合理的解决方案。

Several trends converged to make vibe coding possible. First, modern AI coding assistants (like OpenAI’s Codex, ChatGPT, Anthropic’s Claude, etc.) have become astonishingly good at generating and correcting code. In the same post, Karpathy notes this is “possible because the LLMs…are getting too good”—they have ingested vast swaths of GitHub code and can produce plausible solutions for many tasks.

其次，涌现出了许多新的开发者工具，可以将这些模型无缝集成到编码工作流程中（稍后会详细介绍这些工具）。最后，开发者社区的思维方式正在转变，他们开始信任人工智能的辅助功能，并承担越来越多的工作。这不再仅仅是功能强大的自动补全，而是将整个函数或文件交给人工智能处理。实际上，使用 Vibe 编码就像拥有源源不断的、充满热情的初级开发者，随时准备实现你的任何需求——只不过他们的工作速度堪比云计算。

Second, new developer tools have emerged to integrate these models seamlessly into the coding workflow (more on these tools in a moment). Finally, the developer community’s mindset is evolving to trust AI assistance for bigger and bigger chunks of work. It’s no longer just autocomplete on steroids; it’s handing over whole functions or files to the AI. In practical terms, vibe coding often feels like having an unlimited supply of eager junior developers to implement whatever you ask for—except they work at the speed of cloud computation.

氛围编码最引人注目的优势之一是：生产力提升。早期用户反馈，他们创建软件功能或原型的速度比以前快了十倍到一百倍。例如，Codeium Windsurf 的工程师 John Hoestje 思考道：“为什么只做效率 10 倍的工程师，而不是效率 100 倍的工程师呢？” 这表明，有了合适的 AI 驱动型 IDE，实现卓越的生产力是触手可及的。像Windsurf这样的人工智能增强型集成开发环境（IDE）工具，“可以显著加快开发速度，让您实现100倍的生产力提升。” 虽然100倍可能是一个极端情况，但即使是更保守的研究也发现了巨大的收益。

One of the most eye-popping promises of vibe coding is the productivity boost. Early adopters report being able to create software features or prototypes ten to a hundred times faster than before. For instance, Codeium Windsurf engineer John Hoestje muses, “Why be a 10x engineer when you could be a 100x engineer?” This suggests that, with the right AI-powered IDE, extraordinary productivity is within reach. Tools like Windsurf, an AI-enhanced IDE, “can dramatically accelerate development time, allowing you to achieve that 100x productivity.” While 100x might be an extreme scenario, even more conservative studies find huge gains.

开发者可以在几秒钟内生成样板代码，瞬间修复 bug，甚至让 AI 编写测试或文档，将过去需要几天才能完成的工作流程压缩到短短几个小时。不再受限于打字速度或记忆力，一位拥有 AI 的开发者通常可以在一个周末内完成全栈应用程序的原型设计——这在过去可能需要一个小团队花费数周时间才能完成。这并非炒作；正如我在 2025 年 1 月为Pragmatic Engineer撰写的博文中提到的，调查显示，75% 的开发者已经将某种形式的 AI 集成到他们的工作流程中，许多公司报告称开发速度提高了两位数甚至三位数。简而言之，AI 结对程序员正在将传说中的“10 倍工程师”变成一个非常现实（且触手可及）的“100 倍工程师”现象。

Developers can generate boilerplate code in seconds, fix bugs in the blink of an eye, and even have AI write tests or docs, compressing workflows that used to take days into mere hours. No longer limited by typing speed or memory, a single developer armed with AI can often prototype a full stack application in a weekend—something that might have taken a small team weeks to accomplish in the past. It’s not just hype either; as I noted in a January 2025 blog post for Pragmatic Engineer, surveys show that 75% of developers have already integrated some form of AI into their workflows, and many companies report double- or triple-digit percentage improvements in development velocity. In short, AI pair programmers are turning the mythical “10x engineer” into a very real (and reachable) 100x engineer phenomenon.

为了理解这项技术的革命性意义，不妨考虑一个具体的例子。一位开发者想要构建一个简单的网页应用，用于统计播客脚本中的字数并估算阅读时间。他没有从零开始，而是打开一个人工智能驱动的编码环境，告诉人工智能他的想法。几分钟之内，人工智能就生成了一个可运行的原型。开发者接着说：“把统计计数器改成亮色，并添加导出PDF的功能”，人工智能便会相应地更新代码。最终，一个功能齐全的工具诞生了，只需点击一下即可部署——所有这一切都在不到10分钟的时间内完成。这个真实案例（由一位使用Replit人工智能的开发者分享）展示了“氛围编码”如何实现由高级需求驱动的极速迭代开发。同样，非工程师也开始参与其中：同一篇文章描述了一位没有任何编程背景的失业营销人员，他利用人工智能编码助手构建了100个简单的网页工具，这些工具最终都登上了Product Hunt的榜首。当软件开发的门槛如此之低时，我们不仅提高了经验丰富的开发者的效率，更重要的是，我们从根本上扩大了能够开发软件的人群。

To understand how revolutionary this is, consider a concrete example. A developer wants to build a simple web app that counts words in a podcast script and estimates reading time. Instead of starting from scratch, they open an AI-powered coding environment and tell the AI their idea. Within minutes, the AI produces a working prototype. The developer then says, “Make the stats counters bright colors and add a PDF export,” and the AI updates the code accordingly. The result is a functional tool, deployed with one click—all achieved in under 10 minutes. This real-world scenario (reported by a creator using Replit’s AI) shows how vibe coding enables extremely rapid, iterative development driven by high-level requests. Similarly, nonengineers are jumping in: the same article describes one laid-off marketer with no coding background who used an AI coding assistant to build 100 simple web tools that collectively reached the top of Product Hunt. When the barrier to creating software drops this low, we’re not just increasing productivity for seasoned developers⁠—we’re fundamentally expanding who can develop software in the first place.

然而，直觉式编码也存在严重的弊端。由于过度依赖人工智能，最终生成的代码在理想情况下“运行正常”，但实际上却隐藏着大量漏洞或糟糕的设计决策。如果没有完善的计划或约束，低级逻辑模型（LLM）生成的解决方案可能缺乏适当的错误处理、安全检查或可扩展性。事实上，人工智能生成的代码有时就像建立在沙子上的建筑：它看起来坚固，但隐藏着只有在实际环境中才会显现的问题。我见过这样的案例：开发人员凭借直觉在极短时间内完成了一个功能，但后来却发现代码效率低下且难以维护。这种“纸牌屋”式的代码在压力下很容易崩溃。

However, vibe coding comes with serious caveats. Because you’re deferring so much to the AI, you might end up with code that “works” in the happy path but hides a minefield of bugs or poor design decisions. Without a solid plan or constraints, an LLM might generate a solution that lacks proper error handling, security checks, or scalability. In fact, AI-generated code can sometimes be built on sand: it appears solid but has hidden issues that only surface under real-world conditions. I’ve seen cases where a developer vibed their way to a complete feature in record time, only to discover later that the code was inefficient and hard to maintain. This kind of “house of cards” code can collapse under pressure.

例如，想象一下让人工智能“快速搭建一个用户登录系统”。人工智能或许能迅速生成一个可用的身份验证流程，但它可能使用了简化的加密方法或已知存在漏洞的库。如果你在没有进行深入检查的情况下就部署它，那就等于盲目相信一切都万无一失。经验丰富的工程师都知道这样做风险很大：生产环境中运行的代码必须易于理解且值得信赖。正如一位专家所说：“用即兴创作的方式编写生产代码库显然是危险的。我们软件工程师的大部分工作都涉及对现有系统进行改进，而底层代码的质量和可理解性至关重要。” 而即兴创作的方式，在极端情况下，可能会绕过这些质量关卡。

For example, imagine asking an AI to “whip up a user login system.” The AI might produce a working authentication flow quickly, but perhaps it uses a simplified encryption method or a known vulnerable library. If you deploy that without deeper inspection, you’re taking on faith that everything is sound. Seasoned engineers know that’s risky: code running in production has to be understood and trusted. As one expert put it, “Vibe coding your way to a production codebase is clearly risky. Most of the work we do as software engineers involves evolving existing systems, where the quality and understandability of the underlying code is crucial.” Vibe coding, at its extreme, can bypass those quality gates.

另一个挑战是，Vibe 编码往往会忽略前期规划。传统的软件工程重视清晰性和约束性设计——通过数据模型进行思考，选择合适的模式，并编写至少一份最基本的规范。Vibe 编码方式则反其道而行之：它不提供任何脚手架，而是通过提示直接进入实现阶段。这可能会导致开发过程漫无目的。你可能会因为不断提示而陷入困境——例如，AI 选择了一种你意料之外的状态管理方法或库，现在你不得不要么引导它回到原点，要么接受现状。如果没有初始蓝图，最终的架构可能会显得杂乱无章。这对于快速的概念验证来说尚可接受，但在需要保持一致性的大型代码库中却会造成诸多问题。

Another challenge is that vibe coding tends to downplay upfront planning. Traditional software engineering values designing for clarity and constraint-thinking through data models, choosing appropriate patterns, and writing out at least a minimal spec. Vibe coding flips this: it starts with no scaffolding, diving straight into implementation via prompts. That can lead to a meandering development process. You might prompt your way into a corner—say the AI chooses a state management approach or library you didn’t intend, and now you have to either steer it back or live with it. Without an initial blueprint, the final architecture might be haphazard. This is fine for a quick proof of concept, but it’s troublesome in a larger codebase where consistency matters.

氛围型编程本身并非“坏事”。事实上，它的出现是编程民主化进程的一部分。它降低了软件开发的门槛，就像早期的低代码平台或脚本语言一样。一个积极主动、思路清晰的非工程师，仅凭直觉就能构建一个简单的应用程序。对于经验丰富的开发者来说，直觉编码可以成为强大的头脑风暴工具——它类似于伪代码，但能立即生成可运行的结果。关键在于认识到它的局限性。速度若缺乏严谨性，会导致软件脆弱不堪，因此直觉编码需要有人全程参与并保持警惕。我经常提醒开发者（也提醒我自己）：“直觉编码不是低质量工作的借口。”它应该是解决方案的起点，而不是终点。

Vibe coding isn’t inherently “bad.” In fact, its emergence is part of the ongoing democratization of programming. It lowers the barrier to creating software, much like early low-code platforms or scripting languages did. A motivated nonengineer with a clear idea could potentially build a simple app through vibes alone. And for experienced developers, vibe coding can be a powerful brainstorming tool—it’s like pseudo coding but with immediate, runnable results. The key is recognizing its limits. Speed without discipline can lead to brittle software, so vibe coding requires a vigilant human in the loop. I often remind developers (and myself) that “vibe coding is not an excuse for low-quality work.” It should be the start of a solution, not the end.

人工智能辅助工程方法：与人工智能合作伙伴共同构建结构

The AI-Assisted Engineering Approach: Structure with an AI Partner

与此相反的是人工智能辅助工程——一种更有条理、更有条理的软件构建方式，人工智能在每一步都扮演着辅助驾驶员的角色。在这里，开发商仍然掌握着绝对的主导权。AI 辅助工程包括在传统的软件开发生命周期 (SDLC) 中使用 AI，例如 AI 驱动的自动完成、聊天、代码迁移、错误检测、测试生成以及细粒度（功能、模块、组件）和完整代码生成（见图1-2）。

On the opposite end of our spectrum is AI-assisted engineering—a more structured, methodical way of building software with AI as a copilot at every step. Here, the developer remains very much in the driver’s seat. AI-assisted engineering includes using AI across the traditional software development lifecycle (SDLC), such as AI-powered autocomplete, chat, code migrations, bug detection, test generation, and both granular (function, module, component) and full code generation (see Figure 1-2).

图 1-2.以计划为先的 AI 辅助工程工作流程：开发人员创建规范，向 AI 系统提供有针对性的提示，审查生成的代码片段，并将批准的解决方案集成到他们的项目中。

首先，你需要制定一个计划（即使只是一个简单的计划），概述你需要构建的内容，并预先定义约束条件和验收标准。然后，有针对性地引入人工智能工具，以加速或增强计划中的某些部分。与以灵感为先的“直觉式”编码不同，我们可以将这种以人工智能为支撑的“计划优先”开发模式称为“计划优先”开发。这可以像迷你产品需求文档（针对某个功能的简短产品需求文档）那样正式，也可以像任务清单那样简单。关键区别在于，在让AI自由发挥之前，你需要明确工作的目标和限制条件。

You begin with a plan (even if it’s lightweight), outlining what you need to build and defining the constraints and acceptance criteria up front. Then you incorporate AI tools in a targeted manner to accelerate or enhance parts of that plan. In contrast to prompt-first vibe coding, we might call this “plan-first” development with AI support. This could be as formal as a mini-product requirements document (a short PRD for a feature) or as simple as a checklist of tasks. The crucial difference is that you ground the work in clear intent and constraints before letting the AI loose.

假设一位 React 开发人员的任务是创建一个新的交互式仪表盘组件。在人工智能辅助的工程方法中，他们可能会首先编写组件的职责和 API：

Consider a React developer tasked with creating a new interactive dashboard component. In an AI-assisted engineering approach, they might begin by writing down the component’s responsibilities and API:

仪表盘组件显示分析卡片列表，支持按日期范围筛选，并包含刷新和导出按钮。它应从我们的 API 获取数据（并具备适当的错误处理机制），且必须遵循我们的样式设计规范。

Dashboard component shows a list of analytics cards, supports filtering by date range, and has refresh and export buttons. It should fetch data from our API (with proper error handling), and it must follow our design system for styling.

这份概要本质上就是一份规范。开发者甚至可以快速绘制一个数据模型草图，或者确定哪些现有的实用函数可以复用。只有到了这一步，他们才会引入人工智能：例如，使用支持人工智能的集成开发环境（IDE）或代码助手，根据这份描述生成组件的框架。人工智能可能会提供一个 React 组件的初始实现，其中包含用于数据获取的占位符和模拟事件处理程序。由于开发者提供了清晰的指导，人工智能的输出更有可能符合项目的需求（例如使用正确的设计系统类或调用正确的 API 端点）。代码并非出乎意料，而是源于一个结构清晰的需求。

This outline is essentially a spec. The developer might even sketch a quick data model or identify existing utility functions to reuse. Only then do they bring in the AI: for instance, using an AI-enabled IDE or coding assistant to generate the skeleton of the component based on that description. The AI might provide a starting implementation of the React component with placeholders for data fetching and stubbed event handlers. Because the developer provided clear guidance, the AI’s output is more likely to align with the project’s needs (such as using the right design system classes or calling the correct API endpoints). The code isn’t a surprise; it’s the product of a well-formed request.

人工智能辅助工程并不仅仅局限于为单个组件生成代码。它以可控的方式贯穿整个开发生命周期。对于日常编码任务，像 GitHub Copilot 这样的 AI 自动补全工具可以在你输入时建议接下来的几行代码，从而在你实现已知模式时节省击键次数。例如，当你编写单元测试时，你的 AI 助手可以根据函数名称自动建议断言。说到测试，你可以在功能实现后使用 AI 生成测试用例——将组件的规范或代码输入提示框，即可获得你应该检查的边界情况建议。其理念是增强工程师的工作，而不是取代它。你仍然需要思考逻辑并验证正确性；AI 只是帮你分担了一些繁琐的工作。

AI-assisted engineering doesn’t stop at code generation for a single component. It permeates the entire development lifecycle in a controlled fashion. For routine coding tasks, an AI autocompletion tool like GitHub Copilot can suggest the next few lines as you type, saving keystrokes when you’re implementing known patterns. For example, as you write a unit test, your AI helper might autosuggest assertions based on the function name. Speaking of tests, you might use AI to generate test cases once a feature is in place—feeding the component’s spec or code into a prompt to get suggestions for edge cases you should check. The idea is to augment the engineer’s work, not replace it. You’re still thinking through the logic and verifying correctness; the AI just offloads some of the grunt work.

在代码迁移或重构方面，人工智能可以成为一大助力。想象一下，你需要将一个基于类的 React 组件转换为一个带有 Hooks 的现代函数组件。与其手动完成所有操作，不如让 AI 助手来转换代码，或者至少概述转换步骤。凭借对新旧模式的深刻理解，LLM（生命周期管理）可以生成重构后的代码草稿，然后由你进行审查和润色。这种结构化的 AI 使用方式，能够逐一处理定义明确的任务（例如“将这段代码从 Redux 迁移到 React Context API”），而不是赋予 AI 一个开放式的“构建任何内容”的任务。

When it comes to code migration or refactoring, AI can be a godsend. Imagine needing to convert a class-based React component to a modern function component with hooks. Rather than doing it all manually, you could ask an AI assistant to transform the code or at least outline the steps. With a good understanding of the old and new patterns, an LLM can produce a draft of the refactored code, which you then review and polish. This structured use of AI tackles well-defined tasks (like “migrate this code from Redux to React Context API”) one by one rather than handing the AI an open-ended “build whatever” mandate.

人工智能辅助工程最引人注目的形式或许是利用人工智能根据详细规范生成完整的微型应用程序或功能。现在有很多工具允许你输入应用程序的描述（类似于迷你版产品需求文档），然后就能得到一个可运行的代码库或原型。例如，开发者可以提供以下方面的规范：

Perhaps the most dramatic form of AI-assisted engineering is using AI to generate a full mini-application or feature from a detailed specification. Several tools now allow you to input a description of an app, something akin to a mini-PRD, and get back a working codebase or prototype. For instance, a developer could supply a spec for:

一个使用 React 前端和 Node.js 后端开发的待办事项应用，支持用户身份验证和实时更新。

a to-do list app with React frontend and Node.js backend, supporting user authentication and real-time updates

人工智能工具将搭建项目框架，创建关键组件，并设置数据库架构。

The AI tool would scaffold the project, create the key components, and set up the database schema.

这并非魔法；它只是勤勉的工程师在启动新项目时可能采取的步骤（例如设置目录、选择库、编写样板代码）的加速版。关键在于，人工智能的创造力受到规范中给出的约束。最终生成的是一个符合您提供的需求的最小可行产品 (MVP)。经验丰富的开发人员如果正确对待这个输出，不会认为第一代产品就已可以投入生产。相反，他们会将其视为初稿。他们会运行应用程序，编写或重新生成测试来验证每个功能，检查代码是否存在任何不一致或不安全的配置，并根据需要进行改进。简而言之，他们会运用所有常规的工程严谨性——只是借助人工智能根据蓝图批量生成代码的能力而加快了速度。

This isn’t magic; it’s an accelerated version of what a diligent engineer might do when starting a new project (setting up directories, choosing libraries, writing boilerplate code). The important thing is that the AI’s creativity is bounded by the constraints given in the spec. The result is a minimum viable product (MVP) that adheres to the requirements you provide. An experienced developer, treating this output correctly, will not assume it’s production-ready on the first generation. Instead, they’ll treat it as a first draft. They’ll run the app, write or regenerate tests to validate each feature, review the code for any inconsistencies or insecure configurations, and refine as needed. In short, they’ll apply all their usual engineering rigor—just accelerated by an AI’s ability to produce bulk code from a blueprint.

人工智能辅助工程的目标与氛围编码的目标不同。这里的目标不仅是快速编写出可运行的代码，更是要更高效地编写出高质量的代码。这关乎在提高生产力的同时，保持（甚至提升）结果的可靠性。一个实践人工智能辅助工程的团队可能会说：“我们希望以两倍的速度交付这项功能，但绝不降低我们的标准。”

The goals of AI-assisted engineering are different from those of vibe coding. The aim here is not just to get working code quickly but to get high-quality code more efficiently. It’s about boosting productivity while preserving (or even improving) the reliability of the outcome. A team practicing AI-assisted engineering might say, “We want to deliver this feature two times faster but with zero compromise on our standards.”

这种方法的目标受众通常是拥有成熟流程（代码审查、测试、部署流程）且不愿放弃这些流程的专业开发人员和团队。这些中高级工程师将人工智能视为工具箱中强大的新工具，而不是工具箱的替代品。他们很可能已经目睹过偷工减料的后果，因此他们重视那些能够保持软件可维护性的实践。（相比之下，Vibe Codeing 的目标受众包括独立开发人员（他们自己搭建演示程序）、具有一定编码知识的产品经理，甚至还包括利用人工智能来弥补自身技能不足的相对较新的程序员。）

The audience for this approach is typically professional developers and teams who have established processes (code review, testing, deployment pipelines) that they aren’t willing to abandon. These are intermediate to senior engineers who see AI as a powerful new tool in their toolbox, not a replacement for the toolbox. They likely have seen what happens when you cut corners, so they value practices that keep software maintainable. (By way of comparison, the audience for vibe coding includes solo developers hacking together demos, product-minded folks with some coding knowledge, and even relatively new programmers who leverage AI to compensate for gaps in their expertise.)

人工智能辅助工程的预期是，人类仍然掌控决策，而人工智能提供建议或加速器。代码质量、性能和安全性至关重要，因此，每一段由人工智能生成的代码都必须接受与初级开发人员编写的代码相同的严格审查。要把人工智能视为你的实习生，而不是你的替代品。你可以将任务委派给它，但你必须审查它的工作。正如你绝不会在未经代码审查的情况下部署人类实习生编写的代码一样，你也不应该在不理解人工智能代码的情况下就部署它。这种理念始终将工程纪律置于首位。

The expectations in AI-assisted engineering are that humans remain in control of decisions, and the AI provides suggestions or accelerators. Code quality, performance, and security remain paramount, so every AI-generated piece is subject to the same scrutiny as if a junior developer wrote it. Treat the AI as your intern, not your replacement. You might delegate tasks to it, but you must review its work. Just as you’d never deploy code written by a human intern without a code review, you shouldn’t deploy AI-written code without understanding it. This mindset keeps the engineering discipline front and center.

不同的思维模式，不同的期望

Different Mindsets, Different Expectations

Vibe编码和AI辅助工程是两种截然不同的思维模式。Vibe 编码是自上而下、探索式的：你从一个宽泛的想法开始，然后通过与 AI 的交互逐步实现。这有点像即兴爵士乐——结构极简，为创意即兴发挥留出大量空间，你在演奏的过程中逐渐发现歌曲的雏形。而 AI 辅助工程则是系统化、迭代式的：更像是古典作曲，你从一个主题或动机（你的需求）开始，有条不紊地发展它，或许会在乐谱的节拍内运用一些即兴发挥（AI 的建议）。两者都能产生“音乐”，但过程和结果类型会有所不同。

Vibe coding and AI-assisted engineering are two distinct mindsets. Vibe coding is top-down and exploratory: you start with a broad idea and let the implementation emerge through interaction with the AI. It’s a bit like improvisational jazz—minimal structure, lots of room for creative riffs, and you discover the shape of the song as you play. AI-assisted engineering is systematic and iterative: more like classical composition, where you begin with a theme or motif (your requirements) and methodically develop it, perhaps using some improvisation (AI suggestions) within the measures of a written score. Both can produce “music,” but the process and the kind of result will differ.

对于中级或高级 Web 开发人员来说，对每种方法的预期至关重要。如果你采用的是 Vibe 编码，那么你肯定会感到惊喜。人工智能可能会提出你意想不到的方案——也许它会使用你不太熟悉的库或编程惯用法。它的魅力之一就在于从这些惊喜中学习，或者快速克服那些你觉得繁琐的部分。但你也需要预料到可能会出现一些小问题。Vibe 编码的爱好者应该做好心理准备，他们最终还是要负责解决最后那棘手的问题。它的神奇之处确实存在，但并非完美无缺。

For an intermediate or advanced web developer, your expectations for each approach are key. If you’re vibe coding, you expect to be surprised. The AI might come up with an approach you wouldn’t have written yourself—maybe it uses a different library or a programming idiom you’re less familiar with. Part of the allure is learning from those surprises or quickly getting past things you find tedious. But you also need to expect hiccups. Vibe-coding enthusiasts should go in with eyes open that they’ll be responsible for that tricky last stretch. The magic is real, but it’s not total.

如果你正在实践人工智能辅助工程，你的期望值应该如何设定？对于长期项目而言，这种方式更加审慎，也更贴近实际。你期望人工智能能够节省时间，或许还能启发一两个解决方案，但并非要它包揽你所有的工作。事实上，优秀的AI辅助工程师可能会在更大的框架内，以微剂量的方式运用类似“灵感提示”的方式。例如，在实现一个定义明确的模块时，他们可能会短暂地切换到“灵感提示模式”，询问：“嘿，AI，快速生成一个格式化这些日期的实用函数”，然后立即切换回工程师模式，集成并检查该函数。这种理念的核心在于，AI是你的合作者，在你的指导下工作。你将它擅长的任务（例如样板代码、重复性代码、大范围实现）分配给它，而其余部分（关键逻辑、集成、最终审核）则由你亲自处理。

If you’re practicing AI-assisted engineering, your expectations are more measured and arguably more realistic for long-term projects. You expect the AI to save you time and perhaps inspire a solution or two but not to do your whole job. In fact, a good AI-assisted engineer might use vibe-style prompting in microdoses within a larger framework. For example, while implementing a well-specified module, they might momentarily switch into “vibe mode” to ask, “Hey AI, generate a quick utility function to format these dates,” then immediately switch back to engineer mode to integrate and check that function. The mindset is that AI is a collaborator that works under your guidance. You allocate tasks to it where it excels (like boilerplate, repetitive code, broad-stroke implementations), and you handle the rest yourself (critical logic, integration, final review).

预期目标包括提高生产力、减少重复性错误（例如，人工智能不太可能拼错变量名），以及可能拓宽解决方案的搜索范围（人工智能可能会提出你未曾想到的算法）。但你也需要投入时间进行验证。 调试 AI 辅助代码仍然是调试：你需要运行测试，并在需要时使用调试器单步执行代码。不同之处在于，你可能会发现自己需要调试 AI 为你编写的代码，这是一种全新的体验，需要一定的学习过程。第五章将详细讨论这种体验。

Expectations here include improved productivity, fewer rote mistakes (an AI is less likely to misspell a variable name, for instance), and possibly a broader solution search space (the AI might suggest an algorithm you hadn’t thought of). But you also expect to invest time in validation.  Debugging AI-assisted code is still debugging: you run tests and step through the code in the debugger if needed. The difference is that you might find yourself debugging code the AI wrote for you, which is a new experience that comes with a learning curve. Chapter 5 will discuss this experience in detail.

这两种方法目标凸显了二者之间的根本区别：以“氛围编码”为导向的编程注重短期内的速度，而人工智能辅助工程则注重持续的速度和可靠性。一位“氛围编码”程序员可能会说：“我需要在今晚之前让这个应用运行起来，看看这个想法是否可行。”而一位人工智能辅助工程师则会说：“我需要快速构建这个功能，但它必须足够健壮，能够在我们的代码库中长期存在。”前者只要代码基本能运行就满足了；后者则更关心代码是否足够简洁，以便其他人可以在此基础上进行开发。

The two approaches’ goals highlight a fundamental difference between them: vibe coding optimizes for velocity in the short term, whereas AI-assisted engineering optimizes for sustained velocity and reliability. A vibe coder might say, “I need to get this app running by tonight to see if the idea works.” An AI-assisted engineer would say, “I need to build this feature fast, but it should be robust enough to live in our codebase for years.” The former is satisfied if the code basically functions; the latter cares that the code is clean enough for others to build upon.

这些差异自然会吸引不同的受众。经验不足的开发者或非工程领域的从业者可能更倾向于使用“灵感编码”（vibe coding），因为它降低了入门门槛，并能带来即时的成就感。我曾遇到过一些产品经理和设计师，他们通过灵感提示尝试编写代码，几乎把人工智能当作一个功能强大的 Stack Overflow，能够提供完整的解决方案。另一方面，经验丰富的开发者和工程团队则更倾向于使用人工智能辅助工程。他们之前曾被脆弱的代码坑过，所以他们一开始就秉持着“即使使用新工具来加快速度，也要把事情做好”的原则。他们愿意在前期投入更多精力（例如编写小型产品需求文档、搭建项目结构），以换取长期的回报。

These differences naturally appeal to different audiences. Less-experienced developers or those outside the engineering discipline might lean toward vibe coding because it lowers the barrier to entry and provides instant gratification. I’ve met product managers and designers dabbling in code via vibe prompts, treating the AI almost like a superpowered Stack Overflow that gives them full solutions. On the flip side, seasoned developers and engineering teams tend to favor AI-assisted engineering. They’ve been burned by fragile code before, so they start from a place of “let’s do this right, even if we use new tools to go faster.” They put in a bit more effort up front (writing that mini-PRD, setting up the project structure) in exchange for long-term payoffs.

找到你在光谱中的位置

Finding Your Place on the Spectrum

人们不禁要问：哪种方法更好？事实上，灵感编码和人工智能辅助工程并非互斥的概念：它们代表着同一光谱的两端，而实际工作流程往往融合了两者的元素。开发者可能会先用灵感编码搭建一个新颖的框架，然后再切换到工程模式进行完善。或者，他们通常遵循人工智能辅助的开发方法，但偶尔——比如对于一个无关紧要的一次性脚本或一个临时原型——也会说：“不如试试灵感编码，看看效果如何。”关键在于理解其中的利弊，并在合适的场景下采用合适的方法。

It’s tempting to ask: which approach is better? The truth is, vibe coding and AI-assisted engineering aren’t mutually exclusive categories: they represent two ends of a spectrum, and real-world workflows often blend elements of both. A developer might start a project with a burst of vibe coding to scaffold something novel, then switch into engineering mode to firm it up. Or they might generally follow an AI-assisted discipline but occasionally—for a trivial one-off script or a throwaway prototype—say, “You know what, I’ll just vibe code this and see what I get.” The key is understanding the trade-offs and using the right approach for the right context.

把灵感编码想象成一辆高速探索车：它能带你快速偏离常规路线，非常适合探索发现。而人工智能辅助工程则更像是一列行驶在轨道上的可靠列车：虽然需要事先铺设轨道（规划），但它更安全可靠，更有可能顺利抵达目的地而不脱轨。中高级开发者应该能够驾驭这两种方式，但他们会根据手头的任务进行选择。如果目标是快速创新或构思（例如，在黑客马拉松中或验证想法的可行性时），灵感编码可以提供动力。但请记住，如果计划重用代码，一定要进行优化。如果目标是在专业环境中构建可维护的产品功能，那么采用人工智能辅助工程可以确保你的代码库中不会出现一段无人真正理解的“黑盒”代码。

Think of vibe coding as a high-speed exploratory vehicle: it can take you off the beaten path quickly, and it’s great for discovery. AI-assisted engineering is more like a reliable train on a track: you have to lay down rails first (plan), but it’s a safer bet and more likely to reach a defined destination without derailing. Intermediate and advanced developers should be capable of driving both vehicles, but they’ll choose based on the task at hand. If the goal is to innovate or ideate rapidly (say, in a hackathon or when validating an idea’s feasibility), vibe coding provides momentum. Just remember to tighten things up if you plan to reuse that code. If the goal is to build a maintainable product feature in a professional setting, leaning toward AI-assisted engineering ensures you don’t end up with a black-box chunk of code in your codebase that nobody truly understands.

我观察到一个很有意思的现象：随着开发者使用人工智能工具的经验积累，他们的使用方式往往会自然而然地从追求新奇体验转向工程应用。最初，人工智能能够根据一个指令生成整段代码，这种新奇感非常吸引人——谁不想尝试一下“用语言”创造一个应用程序呢？

One fascinating thing I’ve observed is that as developers gain experience with AI tools, their usage often naturally shifts from the vibe end toward the engineering end. Initially, the novelty of having an AI generate entire blocks of code from a single prompt is alluring—who wouldn’t want to try essentially “talking” an app into existence?

但蜜月期过后，务实的态度开始显现。开发者们开始意识到人工智能的优势和不足。他们学会将问题分解，分阶段地交给人工智能处理，而不是一次性要求它给出完整的解决方案。实际上，他们从“提示艺术家”转变为人工智能的“指挥家”——仍然利用人工智能的创造力，但同时以娴熟的技巧引导它，并遵循清晰的乐谱。在我的实践中，我更加注重提示，通常会编写一小段伪代码或注释，然后让AI完成它们，而不是直接提出开放式问题。这样，我既能获得类似直觉式的流畅性，又能保持在可控的结构之内。

But after the honeymoon, pragmatism kicks in. Developers start to see where the AI shines and where it stumbles. They learn to break problems down and feed them to the AI in pieces rather than asking for the whole solution in one go. In effect, they move from being “prompt artists” to becoming AI “orchestra conductors”—still utilizing the AI’s creative power but guiding it with a skilled hand and following a clear score. In my own practice, I’ve become more deliberate with prompts, often writing small pieces of pseudocode or comments and asking the AI to complete them instead of just asking open-ended questions. This way, I get the benefits of vibe-like fluidity but within a structure I control.

值得注意的是，工具也在不断发展，以支持整个范围。一方面，我们有专门为氛围编码设计的基于聊天的界面和自然语言编码环境，在这些环境中，你甚至可能要等到自己提出要求才能看到代码。另一方面，集成开发环境（IDE）正在添加人工智能功能。它们可以无缝融入传统编码：例如，AI 代码检查器可以提出改进建议，文档生成器可以解释代码，版本控制机器人可以自动创建拉取请求并建议更改以供审查。 这些工具鼓励工程思维，它们融入到通常的开发工作流程（编辑、审查、测试等）中，同时还能利用人工智能。

It’s also worth noting that tooling is evolving to support the entire spectrum. On one side, we have chat-based interfaces and natural-language coding environments explicitly designed for vibe coding, where you might not even see the code until you ask for it. On the other, IDEs are adding AI features that seamlessly blend into traditional coding: for example, AI linters that suggest improvements, documentation generators that explain code, and version-control bots that can automatically create a pull request and suggest changes for review. These tools encourage an engineering mindset by fitting into the usual development workflow (edit, review, test, etc.) while still leveraging AI.

随着最佳实践的出现，直觉式编码和人工智能辅助工程之间的界限或许会逐渐模糊。我们可能会发现，如今看似“随性而为”的做法会受到更多约束，而看似“结构化工程”的做法则会变得更加灵活。事实上，我认为理想的未来是我们可以在两者之间轻松切换：需要时，我们可以利用人工智能探索创新解决方案；而当需要强化和发布软件时，我们则始终运用扎实的工程实践来约束一切。

The distinction between vibe coding and AI-assisted engineering might even blur over time as best practices emerge. We may find that what today feels like “vibing” will gain more guardrails, and what feels like “structured engineering” will become more fluid. In fact, I’d argue that the ideal future is one where we can move up and down this spectrum effortlessly: exploring creative solutions with AI when we want to but always reining things in with solid engineering practices when it’s time to harden and ship the software.

这些方法的多样性代表了我们如今使用人工智能工具方式的重大变革。然而，即便我们不断改进与人工智能协作的技术——无论是通过快速的灵感编码还是结构化的工程工作流程——一场更为根本的变革正在悄然发生。编程本身的本质正在改变。我们正在摆脱开发者必须将想法转化为明确指令的传统模式，走向一个我们可以直接表达意图，并让人工智能负责将其转化为代码的未来。

This spectrum of approaches represents a significant evolution in how we work with AI tools today. Yet even as we refine our techniques for collaborating with AI—whether through rapid vibe coding or structured engineering workflows—a more fundamental transformation is taking shape. The very nature of programming itself is changing. We’re moving away from the traditional paradigm where developers must translate their ideas into explicit instructions and toward a future where we can express our intentions directly and let AI handle the translation into code.

这种转变挑战了我们对程序员身份最基本的认知。几代以来，我们的价值都与我们像机器一样思考的能力紧密相连——将问题分解成计算机可以执行的离散逻辑步骤。但是，当机器不仅能够理解我们告诉它们要做什么，还能理解我们想要什么时，又会发生什么呢？这就是“意图编程”的由来，它不仅代表了一种新的工具或技术，更是对开发者角色的一次根本性重新定义。

This shift challenges our most basic assumptions about what it means to be a programmer. For generations, our value has been tied to our ability to think like machines—to break down problems into discrete, logical steps that computers can execute. But what happens when machines become capable of understanding what we want, not just what we tell them to do? This is where programming with intent enters the picture, representing not just a new tool or technique but a fundamental reimagining of the developer’s role.

提示的兴起：从指令到描述

The Rise of the Prompt: From Instructions to Descriptions

这种转变的核心在于看似不起眼的提示。提示是你提供给人工智能编码系统的输入或问题。本质上，它是对你希望程序做什么的描述，而不是如何执行的指令。这与编写代码的感觉截然不同。例如，你可能不会编写循环来解析文件，而是会提示：

At the heart of this shift is the humble prompt. A prompt is the input or question you give to an AI coding system. In essence, it’s a description of what you want the program to do rather than an instruction for how to do it. This can feel very different from writing code. For example, instead of writing a loop to parse a file, you might prompt:

读取此 CSV 文件并提取所有 18 岁以上用户的电子邮件地址。

Read this CSV file and extract the email addresses of all users older than 18.

人工智能将尝试生成能够实现该描述的代码。

The AI will attempt to generate code that accomplishes that description.

为什么现在会发生这种情况？语言学习模型（LLM）在理解和生成文本（包括编程语言）方面的快速发展改变了游戏规则。这些人工智能模型已经过海量代码和自然语言文本的训练。它们能够解读看似软件行为描述的提示，并将其转化为实现该行为的实际代码。换句话说，它们已经学习了人类描述任务的方式以及这些任务如何转化为代码的模式。

Why is this happening now? The rapid progress of LLMs in understanding and generating text, including programming languages, has been a game changer. These AI models have been trained on vast amounts of code and natural language text. They can interpret a prompt that looks like a description of software behavior and translate it into actual code that implements that behavior. In other words, they’ve learned the patterns of how humans describe tasks and how those tasks translate into code.

这种基于提示的开发的兴起意味着，作为开发者，你越来越多地使用自然语言或伪代码来描述功能和逻辑，而让AI来处理编写语法正确代码的繁重工作。提示成为了你新的思考单位，是对意图的简洁表达。我们已经从告诉计算机“先做X，再做Y，最后做Z”转变为说“我需要完成X、Y和Z”，然后信任AI会填补空白。

This rise of prompt-based development means that, as a developer, you increasingly write descriptions of features and logic in natural language or pseudocode and let the AI handle the heavy lifting of writing syntactically correct code. The prompt becomes your new unit of thought. It’s a concise expression of intent. We’ve gone from telling the computer, “Do X, then Y, then Z” to saying, “I need X, Y, and Z done” and trusting the AI to fill in the blanks.

值得注意的是，编写好的提示本身就是一项技能（我们将在第三章深入探讨）。模糊的提示会导致代码错误或效率低下，就像模糊的需求会让程序员感到困惑一样。你在提示中表达的意图越清晰，人工智能的输出就越能满足你的需求。这就是为什么许多人将编写提示称为新的编程素养。

It’s important to note that writing a good prompt is itself a skill (which we’ll dive into in Chapter 3). A vague prompt can lead to incorrect or inefficient code, just as a vague requirement can confuse a human programmer. The better you can articulate your intent in the prompt, the better the AI’s output will match your needs. This is why many are calling prompt writing the new programming literacy.

工作原理：迭代周期和人工智能在代码生成中的作用

How It Works: The Iterative Cycle and AI’s Role in Code Generation

那么人工智能是如何从如何将你的自由描述转化为实际可运行的代码？关键在于大型语言模型（LLM）能够解读上下文并生成文本。 “大型”中的“大型”指的是其参数（内部配置）的数量，通常高达数十亿甚至更多，这使得它能够捕捉自然语言和编程语言的复杂性。这些模型基于公共代码库、论坛、文档和问答网站进行训练，学习编程语言的语法以及代码解决问题的语义。当你与人工智能程序员互动时，你实际上是在利用这些庞大的学习知识。让我们用简单易懂的方式来解释一下：

So how does an AI go from your free-form description to actual, functioning code? The magic lies in LLMs’ ability to interpret context and generate text. The large in “large language model” refers to the number of parameters (the internal configuration) it has, often billions or more, which enable it to capture the complexities of natural and programming languages. These models have been trained on public code repositories, forums, documentation, and Q&A sites, learning both the syntax of programming languages and the semantics of how code is used to solve problems. When you interact with an AI coder, you’re tapping into this expansive learned knowledge. Let’s break it down in simple terms:

理解提示

Understanding the prompt

什么时候你提供一个提示（例如，“生成一个函数来检查一个数是否为质数”），AI 模型会分析该提示文本。来自 Google、OpenAI 和 Anthropic 的现代模型已经过无数语言和代码示例的训练，因此它们会利用统计模式来推断你的问题。本质上，AI 会尝试预测最有可能用合理的代码完成提示。

When you provide a prompt (for example, “Generate a function that checks if a number is prime”), the AI model analyzes the text of that prompt. Modern models from Google, OpenAI, and Anthropic have been trained on countless examples of language and code, so they use statistical patterns to infer what you’re asking. Essentially, the AI tries to predict the most likely completion of the prompt with code that makes sense.

利用上下文

Leveraging context

这些人工智能系统通常会考虑除单行提示之外的其他上下文信息。例如，如果您在集成开发环境 (IDE) 中使用 AI 助手，该模型可能会考虑当前文件内容、您的编码风格、注释，甚至相关文件。所有这些上下文信息都有助于 AI 生成适合您项目的代码。这与人类开发人员阅读周围代码和文档以了解下一步操作的方式类似。

These AI systems often take into account additional context beyond just the single-line prompt. For instance, if you’re working in an IDE with an AI assistant, the model might also consider the current file content, your coding style, comments, and even related files. All this context helps the AI generate code that fits your project. It’s similar to how a human developer reads surrounding code and documentation to understand what to do next.

生成代码

Generating code

一旦模型理解了你的意图（或者至少做出了最佳猜测），它就会开始生成代码。在底层，它会逐个处理词元（词元是单词或代码符号的一部分），并利用训练过程中学习到的概率进行处理。这个模型并不像传统意义上的模型那样“思考”；它没有编译器或运行时来检查代码。它只是非常擅长以高概率生成正确代码的方式继续文本，因为它之前已经见过大量的示例。如果提示和上下文清晰，它生成的代码可以非常准确，甚至遵循它在训练数据中看到的最佳实践。

Once the model has understood (or at least made a best guess about) your intent, it proceeds to generate code.  Under the hood, it does this one token at a time (a token is a piece of a word or code symbol) using probabilities learned during its training. The model doesn’t “think” in the conventional sense; it doesn’t have a compiler or runtime checking the code. It’s simply very good at continuing text in a way that has a high chance of being correct code because it has seen so many examples before. If the prompt and context are clear, the code it produces can be remarkably accurate and even follow best practices it has seen in its training data.

通过人工监督进行验证

Validating with human oversight

重要的是，人工智能不会擅自运行并为你部署应用程序。您始终参与其中。您可以审核生成的代码，进行测试，并决定接受或修改。在许多情况下，如果您提出要求，AI 还可以提供代码解释，帮助您理解结果。AI 的角色就像一个助手，为您编写代码——但您，作为开发者，仍然是最终的决策者，负责确保代码的正确性并满足项目需求。

Importantly, the AI doesn’t run off and deploy your application for you. You remain in the loop. You review the generated code, test it, and can accept or modify it. In many cases, the AI might also offer an explanation of the code if asked, helping you understand the result. The AI’s role is like an assistant that drafts the code for you—but you, the developer, are still the decision maker who ensures the code is correct and fits the project’s needs.

真正令人印象深刻的是，整个过程只需几秒钟甚至更短的时间即可完成。简而言之，你的描述（提示）会被输入到预测引擎（LLM）中，引擎会生成可能的代码作为输出。虽然模型的内部运作涉及复杂的数学和神经网络层，但对用户而言，这几乎就像是在与一位专家合作，这位专家几乎可以立即回忆起如何实现任何功能。

What’s truly impressive is that this process happens in seconds or less. The high-level overview is that your description (prompt) goes into a prediction engine (the LLM), which produces likely code as output. While the inner workings of models involve complex math and neural network layers, at the user level, it feels almost like collaborating with an expert who can instantly recall how to implement just about anything.

中的一个理解“直觉式编程”（基于意图的编程）的关键在于，它是一个人与人工智能之间迭代协作的过程。你不能只写一个完美的提示，然后就坐等人工智能完美地编写出整个程序。实际上，你需要与人工智能进行反复的交流，形成一个反馈循环，逐步将模糊的想法转化为完善的代码。

One of the key things to understand about vibe coding (intent-based programming) is that it’s an iterative, collaborative process between the human and the AI. You don’t just write one perfect prompt and then sit back as the AI writes an entire program flawlessly. In practice, you engage in a back-and-forth, a feedback loop that gradually takes a vague idea to polished code.

以下是一个典型的循环过程可能如下所示：

Here’s how a typical cycle might look:

第一步：描述你想要的东西

Step 1: You describe what you want

这是您的初始提示或请求。例如：

This is your initial prompt or request. For example:

生成一个函数，根据本金、利率和期限计算每月贷款还款额。

Generate a function to calculate monthly loan payments given principal, interest rate, and term.

步骤二：人工智能提供初步解决方案

Step 2: AI provides an initial solution

人工智能会为该函数生成代码，包括参数和贷款支付公式。它甚至可能还会添加解释公式的注释。

The AI generates code for that function, complete with parameters and formula for loan payments. It might even include comments explaining the formula.

步骤 3：您进行复习和测试

Step 3: You review and test

你查看代码。它逻辑清晰吗？它能处理特殊情况吗？你快速测试一下：如果利率为 0 会怎样？它运行正常吗？你发现它可能无法很好地处理这种情况。

You look at the code. Does it make sense? Does it handle edge cases? You run a quick test: what if the interest rate is 0? Does it behave correctly? You notice it might not handle that scenario well.

步骤 4：完善您的请求或代码

Step 4: You refine your request or code

如果代码不够完美（通常第一次尝试都不会完美），请进行改进。您可以再次提示 AI（“修改函数以优雅地处理 0% 的利率”），或者自己编辑代码并告诉 AI “解释一下这部分”，如果有什么不清楚的地方。这些指导有助于纠正任何误解。

If the code isn’t perfect (and often it won’t be on the first try), refine it. Maybe you prompt the AI again (“Modify the function to handle a 0% interest rate gracefully”), or edit the code yourself and tell the AI, “Explain this part,” if something is unclear. This guidance helps correct any misunderstandings.

第五步：人工智能优化解决方案

Step 5: AI refines the solution

人工智能会接收您的反馈或新的提示并调整代码。现在，该函数会检查是否存在零利率情况并进行相应的处理。

The AI takes your feedback or new prompt and adjusts the code. Now the function checks for zero interest and handles it appropriately.

步骤 6：根据需要重复

Step 6: Repeat as needed

你重复这个循环，直到满意为止。接下来，你或许会要求 AI 为这个函数生成单元测试，以确保它能正常工作。AI 生成测试后，你运行这些测试来验证一切正常。

You continue this loop until satisfied. Perhaps next you ask the AI to also generate unit tests for this function to ensure it works correctly. It does so, and you run them to verify all is well.

这种协作模式很像结对编程，其中一人是人类，另一人是人工智能助手。人类设定方向并了解高层需求，而人工智能则提供建议、编写样板代码并加快繁琐部分的执行速度。对于复杂的任务，两者单独都难以有效完成：人工智能需要人类提供指导和验证，而人类也会将部分工作交给人工智能以加快进度。

This collaboration is much like a pair-programming scenario where one partner is the human and the other is an AI assistant. The human sets the direction and knows the high-level requirements, while the AI offers suggestions, writes boilerplate, and speeds up the tedious parts. Neither is effective alone for complex tasks: the AI relies on the human for direction and validation, and the human offloads some work to the AI to move faster.

至关重要的是，迭代不仅仅是修正错误，更是不断完善解决方案。你可以先给出一个非常粗略的提示，然后根据人工智能的运行结果逐步改进你的意图。

Crucially, the iteration isn’t just about fixing errors; it’s also about evolving the solution. You might start with a very rough prompt and then progressively refine your intent as you see what the AI produces.

这有助于培养实验精神。如果第一次尝试如果答案不正确，你也没浪费太多时间——只需改进提示或调整代码，然后重试即可。在传统编程中，编写一个模块后又不得不丢弃，这会令人沮丧；但对于人工智能生成的代码而言，即使犯错，成本也很低，这鼓励我们探索不同的方法。

This encourages a mindset of experimentation. If the first attempt isn’t right, you haven’t wasted much time—just refine the prompt or tweak the code and try again. In traditional coding, writing a module only to throw it away can be frustrating, but with AI-generated code, the cost of a false start is low, encouraging exploration of different approaches.

VSCode + Copilot：微软的集成式 AI 开发平台

VSCode + Copilot: Microsoft’s Integrated AI Development Platform

通过与 GitHub Copilot 的深度集成， VSCode已从全球最受欢迎的代码编辑器转型为功能全面的 AI 辅助开发平台。这一演变体现了微软的愿景，即在数百万开发者日常使用的 VSCode 环境中保留 AI 功能。

VSCode has transformed from the world’s most popular code editor into a comprehensive AI-assisted development platform through its deep integration with GitHub Copilot. This evolution represents Microsoft’s vision for keeping AI capabilities within the familiar VSCode environment that millions of developers already use daily.

GitHub Copilot 是一款集成到 VSCode 中的 AI 代码助手。它能根据自然语言提示和现有代码上下文，提供代码建议、解释和自动实现。这款集成最突出的特点在于其无缝性——Copilot 不仅仅是一个插件，而是编辑器本身的自然延伸。

GitHub Copilot is an AI-powered coding assistant integrated into VSCode. It provides code suggestions, explanations, and automated implementations based on natural language prompts and existing code context. What sets this integration apart is its seamless nature—Copilot isn’t just an add-on but feels like a natural extension of the editor itself.

VSCode AI 功能的核心在于三种主要的交互模式。首先是内联代码自动补全，Copilot 会在您输入代码时提供内联代码建议，范围从单行代码补全到完整的函数实现。在您编写代码时，屏幕上会显示带有建议的提示文本，您可以按 Tab 键接受建议，也可以逐字部分接受。

The core of VSCode’s AI capabilities centers on three main modes of interaction. First, there’s inline code autocompletion, where Copilot provides inline code suggestions as you type, ranging from single-line completions to entire function implementations. As you write code, ghost text appears with suggestions that you can accept with Tab or partially accept word by word.

其次，还有一个聊天界面，可以通过侧边栏面板访问，您可以在这里讨论代码、提出问题或请求特定的实现。第三点，也许也是最强大的一点，是代理模式。它使用工具调用来访问 Visual Studio 中不断增长的功能集。给定一个目标，它会逐步选择并执行正确的工具。这种代理模式可以分析您的代码库，建议对多个文件进行修改，运行终端命令，响应构建错误，并在循环中进行自我纠正，直到任务完成。

Second, there’s the chat interface, accessible through a sidebar panel where you can have conversations about your code, ask questions, or request specific implementations. Third, and perhaps most powerful, is the agent mode that uses tool calling to access a growing set of capabilities inside Visual Studio. When given a goal, it selects and executes the right tools step-by-step. This agent mode can analyze your codebase, propose edits across multiple files, run terminal commands, respond to build errors, and self-correct in a loop until the task is completed.

VSCode 的 Copilot 实现之所以如此引人注目，是因为它支持模型上下文协议 (MCP)。MCP 为 AI 模型提供了一种标准化的方式，使其能够发现外部工具、应用程序和数据源并与之交互。这意味着 VSCode 中的 Copilot 可以连接到数据库、调用 API、访问文档，并与您的整个开发生态系统集成。例如，启用 GitHub MCP 服务器后，您可以让 Copilot “为我们讨论的每个 bug 创建一个 issue”，它将直接与 GitHub 的 API 交互来创建这些 issue。MCP 带来的可扩展性使 Copilot 从一个代码生成器转变为一个全面的开发助手，它不仅理解您的代码，还理解您的整个工作流程。

What makes VSCode’s Copilot implementation particularly compelling is its support for the Model Context Protocol (MCP). MCP provides a standardized way for AI models to discover and interact with external tools, applications, and data sources. This means Copilot in VSCode can connect to databases, invoke APIs, access documentation, and integrate with your entire development ecosystem. For instance, with the GitHub MCP server enabled, you can ask Copilot to “create an issue for each bug we discussed,” and it will interact directly with GitHub’s API to create those issues. The extensibility through MCP transforms Copilot from a code generator into a comprehensive development assistant that understands not just your code but your entire workflow.

要在专业开发中有效利用 VSCode 和 Copilot，首先要根据任务的复杂程度探索不同的交互模式。对于简单的代码补全和重构，可以依赖内联建议和错误附近出现的闪光图标——点击该图标即可获得 AI 驱动的修复。

To leverage VSCode with Copilot effectively in professional development, start by exploring the different interaction modes based on your task complexity. For simple code completions and refactoring, rely on the inline suggestions and the sparkle icon that appears near errors—click it for AI-powered fixes.

对于更复杂的任务，请打开聊天面板，然后从下拉菜单中选择“代理”来切换到代理模式。代理模式针对跨项目多个文件进行自主编辑进行了优化。它对于不仅需要编辑代码，还需要调用工具和终端命令的复杂任务尤其有用。VSCode 熟悉的界面与 Copilot 不断发展的 AI 功能相结合，为希望在现有开发环境中获得企业级 AI 辅助的团队提供了一个极具吸引力的选择。

For more complex tasks, switch to agent mode by opening the chat panel and selecting “Agent” from the drop-down. Agent mode is optimized for making autonomous edits across multiple files in your project. It is particularly useful for complex tasks that require not only code edits but also the invocation of tools and terminal commands. The combination of VSCode’s familiar interface with Copilot’s evolving AI capabilities offers a compelling option for teams that want enterprise-grade AI assistance without leaving their established development environment.

VSCode + Cline：开源自主编码代理

VSCode + Cline: The Open Source Autonomous Coding Agent

在探索专用的 AI IDE 之前，值得了解一下Cline（前身为 Claude Dev）如何将 VSCode 转变为强大的 AI 辅助开发环境。Cline 代表着与微软 Copilot 截然不同的理念。它并非紧密集成的助手，而是一个能够独立完成复杂、多步骤开发任务的自主编码代理。这款开源扩展为 VSCode 带来了超越专有 AI 编辑器的强大功能，同时又保持了 VSCode 用户所期望的灵活性和可扩展性。

Before exploring purpose-built AI IDEs, it’s worth examining how Cline (formerly Claude Dev) transforms VSCode into a powerful AI-assisted development environment. Cline represents a different philosophy from Microsoft’s Copilot. Rather than being a tightly integrated assistant, it functions as an autonomous coding agent that can take on complex, multistep development tasks from start to finish. This open source extension brings capabilities to VSCode that often exceed those found in proprietary AI editors, all while maintaining the flexibility and extensibility that VSCode users expect.

Cline 的独特之处在于其真正以用户为中心的软件开发方法。当你向 Cline 发出类似“创建一个……”这样的高级请求时，它会立即响应。“用于用户管理及身份验证的 REST API”并非简单地生成样板代码。相反，它会分析您的项目结构，规划跨多个文件的实现，创建正确的文件夹层次结构，安装必要的依赖项，甚至可以运行测试来验证实现。在整个过程中，Cline 始终保持透明，向您展示每个计划操作——文件创建、修改和终端命令——并让您有机会批准或修改每个步骤。这种人机协作的设计在自动化和控制之间实现了完美的平衡，使开发人员既能利用 AI 的功能，又能保持对代码库的掌控。

What distinguishes Cline is its truly agentic approach to software development. When you give Cline a high-level request like “Create a REST API for user management with authentication,” it doesn’t simply generate boilerplate code. Instead, it analyzes your project structure, plans the implementation across multiple files, creates proper folder hierarchies, installs necessary dependencies, and can even run tests to verify the implementation. Throughout this process, Cline maintains transparency by showing you each planned action—file creations, modifications, and terminal commands—and giving you the opportunity to approve or modify each step. This human-in-the-loop design provides the perfect balance between automation and control, allowing developers to leverage AI’s capabilities while maintaining oversight of their codebase.

Cline 的技术能力远不止代码生成。它可以利用浏览器自动化功能来研究 API 文档，通过分析多个文件中的错误跟踪来调试复杂问题，甚至可以通过其 MCP 支持与外部服务进行交互。在调试过程中，您只需粘贴错误消息，Cline 就会跟踪您的代码库以识别根本原因，提出修复方案，实施修复，并添加适当的错误处理以防止类似问题再次发生。其 MCP 集成意味着 Cline 可以连接到您的数据库以了解模式，然后再生成查询；可以访问您的项目管理工具以使实现与需求保持一致；还可以与任何其他兼容 MCP 的服务进行交互。这种可扩展性使 Cline 从一个代码生成器转变为一个能够理解您整个技术生态系统的全面开发合作伙伴。

Cline’s technical capabilities extend far beyond code generation. It can use browser automation to research API documentation, debug complex issues by analyzing error traces across multiple files, and even interact with external services through its MCP support. For debugging, you can paste an error message, and Cline will trace through your codebase to identify the root cause, propose a fix, implement it, and add appropriate error handling to prevent similar issues. Its MCP integration means Cline can connect to your database to understand schemas before generating queries, access your project management tools to align implementations with requirements, or interact with any other MCP-compatible service. This extensibility transforms Cline from a code generator into a comprehensive development partner that understands your entire technical ecosystem.

对于团队而言，Cline 提供了诸多极具吸引力的优势。作为开源软件，团队可以查看其代码、贡献改进或根据自身需求进行 fork——这对于有特定安全或合规性要求的组织至关重要。它支持多种 AI 提供商，包括 Anthropic 的 Claude、OpenAI 的模型、Google 的 Gemini，甚至可以通过 Ollama 支持本地模型，使团队能够根据性能、成本或数据驻留要求灵活选择模型。

For teams, Cline offers several compelling advantages. Being open source, teams can inspect its code, contribute improvements, or fork it for custom needs—crucial for organizations with specific security or compliance requirements. It supports multiple AI providers including Anthropic’s Claude, OpenAI’s models, Google’s Gemini, and even local models through Ollama, giving teams flexibility in model selection based on performance, cost, or data residency requirements.

要高效使用 Cline，请精心设计包含项目背景和约束条件的详细提示，充分利用其在进行任何更改前分析整个代码库的功能，并充分利用其迭代开发能力。Cline 实现某个功能后，您可以立即进行测试，并在同一对话中提出改进建议。VSCode 成熟的生态系统与 Cline 的自主开发功能相结合，为团队提供了一条强大、灵活且经济高效的 AI 辅助开发路径，而无需放弃现有的工具和工作流程。

To use Cline effectively, craft detailed prompts that include project context and constraints, leverage its ability to analyze your entire codebase before making changes, and take advantage of its iterative development capabilities. After Cline implements a feature, you can immediately test it and request refinements in the same conversation context. The combination of VSCode’s mature ecosystem with Cline’s autonomous capabilities offers teams a powerful, flexible, and cost-effective path to AI-assisted development without abandoning their existing tools and workflows.

Cursor：人工智能驱动的代码编辑器

Cursor: The AI-Driven Code Editor

vibe-coding 运动的旗舰工具之一是 Cursor，这是一款 AI 增强型 IDE，它迅速在寻求更流畅编码体验的开发人员中流行起来。Cursor 本质上是一个以人工智能为先导的代码编辑器（实际上是 VSCode 的一个分支），它将最先进的代码生成和理解功能直接构建到您的开发环境中。

One of the flagship tools of the vibe-coding movement is Cursor, an AI-enhanced IDE that has quickly gained popularity among developers seeking a more fluid coding experience. Cursor is essentially an AI-first code editor (a fork of VSCode, in fact) that builds state-of-the-art code generation and understanding right into your development environment.

它的标语是“AI 代码编辑器”，旨在让您使用纯文本指令编写和修改代码。例如，您可以高亮显示一个函数，然后让 Cursor “优化此函数”或“在此处添加错误处理”，它会立即给出代码更改建议。Cursor 的 AI 具有项目感知能力——它会索引您的代码库并理解文件的上下文，因此可以提供更相关的建议（远超简单的自动完成功能）。Cursor IDE 将 LLM 功能集成到其核心界面中。ChatGPT 了解你的代码库。

Its tagline is “The AI Code Editor,” and it’s designed to let you write and modify code using plain language instructions. For example, you can highlight a function and ask Cursor to “optimize this function” or “add error handling here,” and it will instantly suggest the code changes. Cursor’s AI is project-aware—it indexes your codebase and understands the context of your files, so it can make more relevant suggestions (far beyond a simple autocomplete). Cursor IDE integrates LLM capabilities into its core interface. It’s ChatGPT that knows your codebase.

在Cursor 利用高级语言模型（通常是 Anthropic 的 Claude 或 OpenAI 的模型，具体取决于您的设置）来增强其功能。它有一个聊天侧边栏，你可以在这里讨论代码，甚至还有一个“Composer”模式，用于生成多步骤代码。Andrej Karpathy 本人在他的“ vibe-coding”（氛围编码）实验中就使用了 Cursor 的 Composer 功能，并搭配了一个名为“Sonnet”的模型。这套设置让他能够直接与编辑器对话（通过“SuperWhisper”语音转文字功能），并生成代码，然后他可以接受或修改这些代码。

Under the hood, Cursor leverages advanced language models (often Anthropic’s Claude or OpenAI’s models, depending on your setup) to power its features. It has a chat sidebar where you can have conversations about your code, and even a “Composer” mode for multistep code generation. Andrej Karpathy himself has used Cursor’s Composer with a model called “Sonnet” in his vibe-coding experiments. This setup allowed him to literally talk to the editor (using voice-to-text via “SuperWhisper”) and have code appear, which he would then accept or refine.

游标不仅可以生成代码，而且根据指示，也需要编辑现有代码。例如，您可以询问：

Cursor can not only generate code but also edit existing code when instructed. For example, you can ask:

能否简化传输监听器中切换证书的操作？

Could you make it easier to switch certificates in the transport listener?

Cursor 会识别您指的是代码，并建议直接在相关文件中进行编辑，或从相关文件（例如规范 Markdown 文件）中读取内容（参见图 1-3）。免费版通常会在聊天窗口中显示差异供您确认；专业版则可以自动将更改应用到您的工作区。

Cursor will understand you’re referring to your code and propose direct edits in the relevant file or read from relevant files, such as a specification markdown file (see Figure 1-3). In the free version, it often provides the diff in the chat for you to approve; in the pro version, it can auto-apply changes to your workspace.

图 1-3。Cursor的界面是集成人工智能的新一代 IDE 的典范。通过对项目进行索引并迭代提示，像 Cursor 这样的工具能够实现“让编辑器保持运行，去喝杯咖啡，回来后所有功能都已完全运行”，从而带来指数级的生产力提升。

要在专业工作流程中有效使用 Cursor，您应该系统地利用其各项功能。首先在 Cursor 中打开聊天窗口，描述您想要的功能或修复。例如：添加一个包含邮箱和密码的用户登录表单，并设置验证和错误信息。Cursor 会生成所需的代码（创建新文件或修改现有文件），并以草稿形式呈现。您可以查看这些更改（它会显示差异或预览），然后点击“应用”将其合并到您的代码库中。许多开发者都遵循这个流程：提出建议 → 查看 → 接受。如果建议不够完善，您可以进一步完善您的建议（例如，“使用 Tailwind CSS 来设置表单样式”），或者直接让 Cursor 修复您发现的任何问题（“现在，处理邮箱已被注册的情况”）。本质上，您需要不断与您的代码“对话”，直到它看起来完美无缺。

To use Cursor effectively in a professional workflow, you should take advantage of its capabilities systematically. Start by opening a chat in Cursor and describe the feature or fix you want. For instance: add a user login form with email and password, including validation and error messages. Cursor will generate the needed code (creating new files or modifying existing ones) in a draft state. You can review these changes (it shows a diff or preview) and then hit “Apply” to merge them into your codebase. Many developers follow this loop: prompt → review → accept. If the suggestion isn’t perfect, you can refine your prompt (for instance, “Use Tailwind CSS for styling the form”) or just ask Cursor to fix any issues you spot (“Now, handle the case where the email is already registered”). In essence, you converse with your code until it looks good.

Cursor 在理解错误和日志方面也表现出色。如果您运行代码后得到回溯信息或错误消息，您可以将其粘贴到 Cursor 聊天窗口中，人工智能通常会对其进行分析并提出修复建议。这使得调试变成了一种协作体验：与其手动搜索 Google 或 Stack Overflow，Cursor 的 AI 通常可以精确定位问题，甚至编写补丁。不过，验证这些修复仍然很重要，因为 AI 并非总能一次成功。

Cursor also excels at understanding errors and logs. If you run your code and get a traceback or error message, you can paste it into the Cursor chat, and often the AI will analyze it and suggest a fix. This turns debugging into a cooperative experience: rather than you manually searching Google or Stack Overflow, Cursor’s AI can often pinpoint the problem and even write the patch. That said, it’s wise to verify the fixes, as the AI might not always get it right on the first try.

另一个专业技巧：利用 Cursor 的跨文件处理功能。您可以选择一组文件（或在提示中告知项目上下文），以便它在生成代码时考虑您的整个代码库。例如：在后端添加一个新的 API 端点以支持登录表单，并将其连接到我们刚刚创建的前端表单。Cursor 会调用它刚刚编写的前端代码，并帮助您构建相应的后端逻辑。与之前只能逐个文件运行的代码助手相比，这种项目级上下文功能可谓是颠覆性的。

Another pro tip: use Cursor’s ability to take multiple files into account. You can select a set of files (or let it know about project context in the prompt) so that it considers your whole codebase when generating code. For example: add a new API endpoint in the backend to support the login form, and connect it to the frontend form we just made. Cursor will recall the frontend code it just wrote and help craft the corresponding backend logic. This project-wide context is a game changer compared to earlier coding assistants that only worked file by file.

总而言之，Cursor 就像一个 24/7 全天候驻留在 IDE中的AI 结对程序员。它非常直观（你可以用简单的语言与它交流），并且可以直接更新你的代码。你越是练习将任务分解并用清晰的指令提示 Cursor，就越能发现自己能在短时间内完成更多的工作。它尤其适合迭代开发：你先构建一部分代码，运行并查看输出，然后立即让 Cursor 调整或扩展代码，如此循环往复。

In summary, Cursor is like having an AI pair programmer inside your IDE, 24/7. It’s intuitive (you chat with it in plain language), and it can update your code directly. The more you practice breaking down tasks and prompting Cursor with clear instructions, the more you’ll find you can accomplish in a short time. It’s particularly great for iterative development: you build a bit, run and see output, then immediately ask Cursor to adjust or extend the code, and repeat.

Windsurf：一款具备完整代码库索引功能的AI驱动型IDE

Windsurf: An AI-Powered IDE with Full Codebase Indexing

又一颗冉冉升起的新星氛围编码工具箱是 Windsurf，这是一个人工智能驱动的开发环境，可将代码理解提升到一个新的水平。Windsurf 由Codeium 背后的团队打造，其独特之处在于它会对你的整个代码库进行索引，并在你工作时利用检索技术将相关代码片段提供给 AI 模型。实际上，这意味着 Windsurf 非常擅长处理大型项目，即使问题的答案分散在多个文件中。它的核心使用了一种叫做检索增强生成（RAG）的技术，这是一种比较花哨的说法，意思是它会查找代码中与你的提示相关的部分，并将该上下文提供给人工智能，以便其建议与你现有的代码保持一致。

Another rising star in the vibe-coding toolbox is Windsurf, an AI-driven development environment that takes code understanding to the next level. Windsurf is built by the team behind Codeium, and it differentiates itself by indexing your entire codebase and using retrieval techniques to feed the relevant pieces to the AI model as you work. In practical terms, this means Windsurf is extremely good at handling large projects where the answer to your question might be spread across many files. Its core uses something called retrieval-augmented generation (RAG), which is a fancy way of saying it looks up the parts of your code that are relevant to your prompt and provides that context to the AI so that its suggestions are consistent with your existing code.

这对开发者来说意味着什么？假设你刚接触一个大型代码库，需要添加一个功能。使用 Windsurf，你可以用自然语言提问：

What does this look like for a developer? Let’s say you’re new to a big codebase and need to add a feature. With Windsurf, you can ask in natural language:

用户身份验证逻辑在代码库的哪个位置处理？

Where in the codebase is the user authentication logic handled?

它会搜索整个它会建立索引并指向正确的文件甚至函数。然后，你可以打开一个聊天窗口（Windsurf 称之为“级联视图”，可通过 Cmd+L 触发），并说：

It will search through the index and point you to the right file or even function. Then, you might open a chat (Windsurf calls it the “Cascade” view, triggered by Cmd+L) and say:

在登录流程中添加基于手机的双因素身份验证。

Add a phone-based two-factor authentication to the login flow.

因为 Windsurf 了解您的身份验证逻辑，所以它可以生成跨多个文件（数据库、API、前端）的更改来实现此功能，从而做出与您的系统结构相符的明智选择。

Because Windsurf has the context of your auth logic, it can generate changes spanning multiple files (database, API, frontend) to implement this, making informed choices that line up with how your system is structured.

Windsurf 的写入模式可以大胆地为您应用更改：它会自动创建新文件或编辑现有文件，而不仅仅是在侧边栏中显示差异建议。这可以节省大量时间：您无需从建议中复制粘贴，即可看到项目在原地不断演进。Windsurf 本质上会在确信无误时代表您执行操作，就像一位自主的初级开发人员在代码库中实现各种功能一样。（Cursor 的理念则更为保守，会要求您确认，尽管其专业版也具备“自动应用”功能。）

Windsurf’s Write mode can boldly apply changes for you: it will create new files or edit existing ones automatically rather than just suggesting diffs in a sidebar. This can be a huge time-saver: instead of copy-pasting from suggestions, you see your project evolving in place. Windsurf essentially tries to take actions on your behalf when it’s confident, behaving like an autonomous junior dev implementing features across the codebase. (Cursor’s philosophy is a bit more conservative, asking for confirmation, although its Pro version has an “auto-apply” feature too.)

为了有效地利用风帆冲浪，它有助于了解其优势：

To leverage Windsurf effectively, it helps to understand its strengths:

代码库问答

Codebase Q&A

你几乎可以用纯英语查询你的代码库。就像为你的项目定制一个 Stack Overflow 一样。这对于大型遗留项目来说非常有用，因为在这些项目中，查找某个代码的定义位置可能需要花费数小时。Windsurf 可以通过从索引代码中提取信息，在几秒钟内给出答案。

You can query your codebase in plain English, almost like a custom Stack Overflow for your project. This is great for large legacy projects where finding where something is defined can take hours. Windsurf will answer in seconds by pulling from the indexed code.

全球背景建议

Global context suggestions

因为它提供了相关信息Windsurf 可以将文件导入模型，并很好地处理诸如“重构支付模块以使用我们编写的新日志记录实用程序”之类的任务，因为它既了解支付模块又了解日志记录实用程序。

Because it feeds relevant files into the model, Windsurf can handle tasks like “Refactor the payment module to use the new logging utility we wrote” very well, as it knows about both the payment module and the logging utility.

运行模式

Modes of operation

Windsurf 有多种模式（如前面提到的自动完成、聊天、命令和级联）。Cascade 类似于超级聊天，可以考虑更广泛的上下文。“写入模式”（在聊天窗口中）会实际执行更改。作为工程师，您可以决定赋予它多大的自主权。

Windsurf has multiple modes (Autocomplete, Chat, Command, and Cascade, as mentioned). The Cascade is like a superchat, where it can consider a broader context. The Write mode (within chat) actually executes changes. You, as the engineer, can decide how much autonomy to give it.

对于团队而言，Windsurf 可以像 Cursor 一样轻松集成到日常开发中。在两者之间进行选择时，一些开发者更倾向于 Windsurf，因为它速度更快、响应更灵敏（他们指出 Windsurf 生成和应用更改的速度更快），而且由于其索引功能，Windsurf 更适合处理大型项目。另一方面，Cursor 的界面可能更符合 VSCode 用户的使用习惯。这并非非此即彼的选择——有些工程师会同时使用两者，或者团队可能会选择其中一种作为标准。

For a team, Windsurf can be integrated into daily development much like Cursor. When picking between them, some developers prefer Windsurf for its speed and boldness (noting that it feels faster to generate and apply changes) and for working with very large projects due to its indexing. On the other hand, Cursor’s interface might feel more familiar to VSCode users. It’s not necessarily an either/or choice—some engineers keep both handy, or teams might standardize on one.

总而言之，如果您想要一个真正能在编写代码前“阅读文档/代码”的AI编码助手，Windsurf绝对是您的理想之选。它能自动查找信息，最大限度地减少出现莫名其妙的函数或变量命名错误的情况。为了充分发挥其效用，您可以提供清晰的指令，让它在“写入模式”下处理大型任务；但对于细微的修改，您也可以更谨慎地使用它。务必检查它所做的更改（它会显示给您），尤其是关键代码。Windsurf很智能，但并非完美无缺。如果使用得当，它就像一个超级智能的IDE，了解您的整个项目，并能将您的想法应用到整个项目中，从而显著提升您的开发效率。

In sum, Windsurf is an excellent tool if you want an AI coding assistant that truly “reads the docs/code” before writing. It minimizes the chances of hallucinated functions or misnamed variables because it can look things up. To get the most out of it, feed it clear instructions and let it rip in Write mode for big tasks, but also feel free to use it in a more controlled fashion for delicate changes. Always review the changes it makes (it will show them to you), especially for critical code. Windsurf is smart, but it’s not infallible. Used wisely, it’s like a hyperintelligent IDE that knows your entire project and can implement ideas across it, giving a serious boost to your throughput.

了解模型类别

Understanding Model Categories

当今的编码模型通常低于根据其方法和优势，可将其分为以下几类：

Today’s coding models generally fall into several categories based on their approach and strengths:

速度优化

Speed optimized

这些功能优先考虑快速响应，非常适合实时代码补全和快速迭代。它们通常能提供更低的延迟，但代价是复杂任务的准确性略有降低。

These prioritize quick responses and are ideal for real-time code completion and rapid iteration. They typically offer lower latency at the cost of slightly reduced accuracy on complex tasks.

深度推理

Deep reasoning

这些问题需要更多时间来“仔细思考”。 但擅长复杂调试、架构决策和多步骤问题解决。具备高级推理能力的模型可以逐步分解复杂的错误。

These take more time to “think through” problems but excel at complex debugging, architectural decisions, and multistep problem solving. Models with advanced reasoning capabilities can break down complex bugs step-by-step.

多式联运强国

Multimodal powerhouses

有些模型不仅可以处理代码和文本，还可以处理图像、图表，甚至视频内容。这使得它们对于理解视觉文档或处理 UI/UX 元素特别有价值。

Some models can process not just code and text but also images, diagrams, and even video content. This makes them particularly valuable for understanding visual documentation or working with UI/UX elements.

开源替代方案

Open source alternatives

DeepSeek 的突出之处在于提供它拥有与闭源模型相当的人工智能能力，无需付费或注册，但可能缺少一些功能，例如图像生成或网页浏览功能。

DeepSeek stands out by offering a comparable level of AI power to closed-source models without requiring payment or sign-up, though it may lack some features like image generation or web browsing capabilities.

选择适合您任务的模型

Choosing the Right Model for Your Task

与其寻找单一的“最佳”模式，不如寻找成功的模式开发人员现在将模型与特定任务相匹配：

Rather than seeking a single “best” model, successful developers now match models to specific tasks:

• 对于快速原型制作和一般编码，针对速度和广泛语言支持进行优化的模型效果很好。

• For rapid prototyping and general coding, models optimized for speed and broad language support work well.

• 对于复杂的调试和系统设计，能够有条不紊地追踪逻辑的深度推理模型是一个不错的选择。

• For complex debugging and system design, deep reasoning models that can trace through logic methodically are a good choice.

• 对于大型代码库，选择具有广泛上下文窗口的模型，以便保持项目范围内的感知。

• For working with large codebases, choose models with extensive context windows that can maintain project-wide awareness.

• 对于预算有限的团队来说，开源模式无需订阅费用即可提供极佳的价值。

• For budget-conscious teams, open source models provide excellent value without subscription costs.

现在许多工具都支持多种 AI 模型，包括 OpenAI、Claude 和 Gemini 的变体，以及专有模型，允许开发人员根据手头的任务在它们之间进行切换。

Many tools now support multiple AI models, including OpenAI, Claude, and Gemini variants, along with proprietary models, allowing developers to switch between them based on the task at hand.

适用于任何型号的实用技巧

Practical Tips for Any Model

无论你选择哪种人工智能模型，某些做法都能持续提升结果。首先，提供丰富的上下文信息。不要仅仅提出“支付处理功能”的要求。相反，请分享您的数据模型、现有代码模式、错误处理方法以及任何具体需求。您提供的背景信息越多，最终生成的代码就越能与您的代码库相匹配。

Regardless of which AI model you choose, certain practices consistently improve results. First, provide rich context. Don’t just ask for “a payment processing function.” Instead, share your data models, existing code patterns, error-handling approaches, and any specific requirements. The more context you provide, the better the output will align with your codebase.

大多数现代编码模型都擅长自我审查其输出。在收到生成的代码后，请模型检查潜在问题、提出改进建议或解释其推理过程。这种自我审查通常可以发现一些不易察觉的错误或提出优化建议。

Most modern coding models excel at reviewing their own output. After receiving generated code, ask the model to check for potential issues, suggest improvements, or explain its reasoning. This self-critique often catches subtle bugs or suggests optimizations.

利用模型维护对话上下文的功能。先从基本实现入手，然后通过后续请求逐步完善。这种迭代方法通常比一开始就试图指定所有内容效果更好。

Use the model’s ability to maintain conversation context. Start with a basic implementation, then progressively refine it through follow-up requests. This iterative approach often yields better results than trying to specify everything up front.

每种模型在解决问题的方式上都有一些细微的差别。有些模型的解释比较冗长，而有些则更简洁。有些模型默认使用较新的语法，而有些则更倾向于保守的语法。了解这些倾向有助于你设计出更好的提示。

Each model has subtle differences in how it approaches problems. Some are more verbose in their explanations, while others are more concise. Some default to newer syntax, while others play it safe. Learning these tendencies helps you craft better prompts.

Google Gemini：多模态编码强机

Google Gemini: The Multimodal Coding Powerhouse

谷歌的 Gemini系列产品凭借其原生多模态功能，代表了人工智能辅助开发领域的一次根本性转变。与主要基于文本和代码训练的模型不同，Gemini 从一开始就被设计成能够无缝理解和处理文本、代码、图像、视频和其他数据格式。这使其在现代开发工作流程中表现得异常强大，因为在这些工作流程中，视觉上下文与文本信息同样重要。

Google’s Gemini family represents a fundamental shift in AI-assisted development through its native multimodal capabilities. Unlike models that were primarily trained on text and code, Gemini was architected from the ground up to seamlessly understand and work across text, code, images, video, and other data formats. This makes it exceptionally powerful for modern development workflows where visual context matters as much as textual information.

Gemini 的多模态特性在 Web 开发场景中尤为宝贵。开发者可以分享设计稿的截图，Gemini 能够生成与视觉风格完全匹配的像素级精确实现。它尤其擅长理解图表、示意图和 UI 元素，是视觉设计转化为功能代码的理想伙伴。这种能力远不止于简单的图像识别：Gemini 能够推理视觉元素、理解设计模式，并在整个项目中保持美学上的一致性。

The multimodal nature of Gemini proves particularly valuable in web development scenarios. Developers can share screenshots of design mockups, and Gemini can generate pixel-perfect implementations that match the visual style. It excels at understanding charts, diagrams, and UI elements, making it an ideal partner when translating visual designs into functional code. This capability extends beyond simple image recognition: Gemini can reason about visual elements, understand design patterns, and maintain aesthetic consistency across an entire project.

Gemini与开发工作流程的集成通过流行的编辑器（VSCode、Cursor、Windsurf）和插件（如 Cline 和 Code Assist），开发者可以拥有强大的自定义选项，这些选项可以从个人偏好扩展到团队标准。开发者可以为重复性任务创建自定义命令，建立适用于每次代码生成的规则，并在大型代码库中保持一致的编码模式。慷慨的免费版本使其能够被学生、业余爱好者和初创公司所接受，而企业级功能则可满足复杂的组织需求。

Gemini’s integration with development workflows through popular editors (VSCode, Cursor, Windsurf) and plug-ins like Cline and Code Assist offers developers powerful customization options that scale from individual preferences to team-wide standards. Developers can create custom commands for repetitive tasks, establish rules that apply to every code generation, and maintain consistent coding patterns across large codebases. The generous free tier makes it accessible to students, hobbyists, and startups, while enterprise features support complex organizational requirements.

Gemini 在编程领域脱颖而出的原因在于它能够在保持高效运行的同时，深入思考问题。该模型能够根据具体问题灵活切换：对于简单任务快速响应，对于复杂挑战则进行深入推理。这种灵活性，结合其强大的可视化理解能力，使其在全栈开发中尤为有效，因为在全栈开发中，后端逻辑和前端美学都至关重要。

What distinguishes Gemini in the coding landscape is its ability to think deeply about problems while maintaining practical speed. The model can alternate between quick responses for simple tasks and extended reasoning for complex challenges, adapting its approach based on the problem at hand. This flexibility, combined with its visual understanding capabilities, makes it particularly effective for full stack development where both backend logic and frontend aesthetics matter equally.

克劳德：推理大师

Claude: The Reasoning Virtuoso

Anthropic Claude 的编码辅助方法以透明度和深度推理能力为中心。Claude 系列，特别是 Sonnet 模型，已经证明自己在需要仔细分析和逐步解决问题的复杂软件工程任务方面具有非凡的能力。Claude 的独特之处在于它能够展示其思考过程，使开发人员能够跟随其推理过程并验证其逻辑，然后再实施解决方案。

Anthropic Claude’s approach to coding assistance centers on transparency and deep reasoning capabilities. The Claude family, particularly the Sonnet models, has established itself as exceptionally capable at complex software engineering tasks that require careful analysis and step-by-step problem solving. What sets Claude apart is its ability to show its thinking process, allowing developers to follow along with its reasoning and verify its logic before implementing solutions.

文物功能代表了一种开发者与AI代码助手交互方式的范式转变。Claude不再只是在聊天界面中提供代码，而是创建了一个专属的工作空间，用户可以在这里实时查看、编辑和预览代码。这种交互式环境对于前端开发、数据可视化以及任何需要即时视觉反馈来加速开发流程的场景都尤为强大。开发者可以在同一对话中迭代设计、测试功能并改进实现。

The Artifacts feature represents a paradigm shift in how developers interact with AI coding assistants. Rather than simply providing code in a chat interface, Claude creates a dedicated workspace where code can be viewed, edited, and previewed in real time. This interactive environment is particularly powerful for frontend development, data visualization, and any scenario where immediate visual feedback accelerates the development process. Developers can iterate on designs, test functionality, and refine implementations all within the same conversation.

Claude 在实际软件工程基准测试中表现出色，在缺陷修复、功能实现和代码重构等任务中始终名列前茅。它的优势不仅在于生成代码，更在于理解软件项目的更广泛背景。Claude 可以分析现有代码库，识别模式和反模式，提出架构改进建议，并确保与既定的编码风格保持一致。这使得它对于全新项目和遗留系统维护都极具价值。

Claude demonstrates exceptional performance on real-world software engineering benchmarks, consistently ranking among the top models for tasks like bug fixing, feature implementation, and code refactoring. Its strength lies not just in generating code but in understanding the broader context of software projects. Claude can analyze existing codebases, identify patterns and antipatterns, suggest architectural improvements, and maintain consistency with established coding styles. This makes it invaluable for both greenfield projects and legacy system maintenance.

该模型的内存和上下文管理方法使其能够在长时间的编码过程中逐步建立理解。在处理大型项目时，Claude 可以提取并保留有关代码库结构、设计决策和项目特定模式的关键信息。随着开发的推进，这些积累的知识使其能够提供越来越相关且更具上下文意义的建议，使其更像是一个随着时间推移逐渐熟悉项目的团队成员，而不是一个没有状态的助手。

The model’s approach to memory and context management enables it to build understanding over extended coding sessions. When working with large projects, Claude can extract and retain key information about the codebase structure, design decisions, and project-specific patterns. This accumulated knowledge allows it to provide increasingly relevant and contextual suggestions as development progresses, making it feel more like a team member who grows familiar with the project over time rather than a stateless assistant.

ChatGPT：多功能编码助手

ChatGPT: The Versatile Coding Companion

ChatGPT已成为人工智能编码助手领域的瑞士军刀，其价值不在于其专业功能，而在于其卓越的多功能性和广泛的知识库。它在开发者工具包中的定位独树一帜。其他模型可能直接集成到集成开发环境 (IDE) 中，或提供专门的编码环境，而 ChatGPT 则像一个随时可用的编程顾问，开发者可以在整个工作日将其保持在浏览器中打开的状态。

ChatGPT has established itself as the Swiss Army knife of AI coding assistants, valued not for specialized features but for its remarkable versatility and broad knowledge base. Its position in the developer toolkit is unique. While other models might integrate directly into IDEs or offer specialized coding environments, ChatGPT serves as an always available programming consultant that developers keep open in their browsers throughout the workday.

ChatGPT 的对话式界面使其在探索性问题解决和学习方面异常高效。开发者经常使用它进行模拟调试，粘贴问题代码，并在自然对话中思考问题。其广泛的训练使其能够识别几乎所有常用编程语言、框架和工具中的模式。无论是调试正则表达式、理解晦涩的错误信息，还是探索陌生的库文档，ChatGPT 都能从其全面的知识库中提供相关的见解。

The conversational interface of ChatGPT makes it exceptionally effective for exploratory problem solving and learning. Developers regularly use it for rubber-duck debugging, pasting in problematic code and thinking through issues in natural conversation. Its extensive training enables it to recognize patterns across virtually every programming language, framework, and tool in common use. Whether debugging a regex expression, understanding an obscure error message, or exploring unfamiliar library documentation, ChatGPT can provide relevant insights drawn from its comprehensive knowledge base.

ChatGPT 的优势在于它能够弥合人类意图和代码实现之间的差距。它擅长双向翻译——能够将自然语言描述转换为可运行的代码，并用通俗易懂的英语解释复杂的代码。这使其在文档编写、代码审查和团队内部知识转移方面具有不可估量的价值。开发人员可以粘贴不熟悉的代码并获得对其功能的清晰解释，或者描述期望的行为并获得适用于多种编程范式的相应实现。

ChatGPT’s strength lies in its ability to bridge the gap between human intent and code implementation. It excels at bidirectional translation—converting natural language descriptions into working code and explaining complex code in plain English. This makes it invaluable for documentation, code reviews, and knowledge transfer within teams. Developers can paste unfamiliar code and receive clear explanations of its functionality, or describe desired behavior and receive appropriate implementations across multiple programming paradigms.

该模型的通用性不仅限于传统编程语言，还涵盖配置文件、脚本、数据格式和领域特定语言。虽然专业的编码工具在其专注领域内表现出色，但 ChatGPT 却能为整个软件开发任务提供宝贵的帮助。这种广度使其在处理不同技术交叉领域或遇到跨领域问题时尤为有用。它能够在长时间的对话中保持上下文关联，使开发人员能够迭代地探索复杂问题，并通过协作对话不断完善解决方案。

The model’s versatility extends beyond traditional programming languages to configuration files, scripts, data formats, and domain-specific languages. While specialized coding tools excel within their focused domains, ChatGPT provides valuable assistance across the entire spectrum of software development tasks. This breadth makes it particularly useful when working at the boundaries between different technologies or when encountering problems that span multiple domains. Its ability to maintain context across extended conversations allows developers to explore complex problems iteratively, refining solutions through collaborative dialogue.

Vibe Coding 的理想应用场景

Ideal Use Cases for Vibe Coding

就像某些架构适合解决某些问题一样，氛围在软件开发领域，编码有其“优势领域”。

Just as certain architectures are suited for certain problems, vibe coding has its “sweet spots” in the software development landscape.

人工智能仍面临哪些挑战

Where AI Still Struggles

尽管目前的AI编码工具令人印象深刻，但它们并非魔法。有些问题，人工智能仍然难以可靠地处理，通常需要人类的洞察力或传统的编程技术。了解这些局限性有助于设定合理的预期，并帮助你规划何时应该介入，何时应该重新掌控局面。

As impressive as current AI coding tools are, they are not magic. There are classes of problems that remain difficult for AI to handle reliably, often requiring human insight or traditional coding techniques. Knowing these limitations helps set the right expectations and lets you plan when to lean in versus when to take back the reins.

其局限性包括以下几点：

The limitations include the following:

高度复杂的系统

Deeply complex systems

如果你要处理非常复杂的算法或人工智能可能从未见过的全新问题，它可能会束手无策。例如，根据研究论文编写全新的算法，或者编写编译器或高度并发系统——这些都涉及复杂的逻辑，需要真正的理解和创造性的思维飞跃。人工智能可以尝试，但它可能会犯一些细微的错误。

If you’re dealing with very complex algorithms or novel problems that the AI likely hasn’t seen, it may flounder. For example, writing a brand-new algorithm from a research paper or doing something like writing a compiler or highly concurrent system—these involve intricate logic that requires true understanding and often creative leaps. AI can try, but it might get things subtly wrong.

在像这样的复杂领域，人工智能倾向于生成近似正确但并非完全正确的代码，这会导致大量的反复修改。正如第3章和第4章将要讨论的，人工智能很难确保最后30%左右的正确性。这与我所说的“ 70%难题”有关——人工智能可以快速完成大部分工作，但最后阶段却十分棘手。经验丰富的开发人员可能会使用人工智能为这类复杂任务生成框架或辅助函数，但核心逻辑则由他们自己编写。

In complex domains like these, the AI’s tendency to make approximately correct but not exactly correct code can lead to a lot of back-and-forth. As Chapters 3 and 4 will discuss, the final 30% or so of correctness is very hard for the AI to nail down. This is related to what I call the 70% problem—AI gets you most of the way quickly, but the last part is tough. An experienced developer might use AI to generate skeletons or helper functions for such complex tasks but do the core logic themselves.

底层优化和系统编程

Low-level optimizations and systems programming

当前的AI模型主要基于高级语言和抽象概念进行训练。如果需要进行底层位操作、为特定微控制器编写高度优化的C代码，或者生成向量化的SIMD指令，AI可能就不可靠了。它生成的代码可能看起来合理，但在硬件层面上并非真正最优，甚至可能不正确。

Current AI models are primarily trained on high-level languages and abstractions. If you need to do low-level bit-twiddling, write highly optimized C code for a specific microcontroller, or generate vectorized SIMD instructions, the AI might not be reliable. It might produce code that looks plausible but isn’t truly optimal, or even correct, on a hardware level.

同样，对于内存管理或实时性限制等问题，人工智能并没有真正的概念（它不会在脑海中模拟 CPU 缓存）。因此，对于性能关键型代码，您要么需要彻底测试人工智能的建议，要么需要手动编写这些部分。也就是说，人工智能仍然可以通过提供初始模板或解释汇编语言来提供帮助，但在这些情况下，您不能盲目信任它。

Similarly, for things like memory management or real-time constraints, the AI doesn’t have a real concept of those (it doesn’t simulate a CPU cache in its head). So for performance-critical code, you’ll want to either thoroughly test AI suggestions or write those parts manually. That said, AI might still help by providing a starting template or explaining assembly, but you cannot blindly trust it in these scenarios.

独特或小众的框架

Unique or niche frameworks

如果你使用的是一个非常新或冷门的框架，在人工智能训练期间并不存在，那么它将无法识别。在这种情况下，人工智能可能会尝试进行泛化，或者生成看似合适但实际上调用了不存在的函数（产生幻觉）或使用了过时的API版本的代码。例如，如果上个月发布了一个包含重大变更的新Web框架版本，人工智能将无法识别这些变更。它可能会给出旧版本的代码。在这种情况下，你必须参考文档，甚至可能需要通过在提示符中提供文档上下文来帮助训练人工智能（基本上是即时训练）。

If you’re using a very new or obscure framework that wasn’t around during the AI’s training, it won’t know about it. In such cases, the AI might try to generalize or might produce code that looks like it fits but actually call functions that don’t exist (hallucinations) or use outdated versions of the API. For example, if a new web framework version came out last month with breaking changes, the AI won’t know about those changes. It might give you code for the old version. In these cases, you have to fall back on documentation and perhaps even help train the AI by feeding it context from the docs within your prompt (basically teaching it on the fly).

创意用户界面/用户体验设计

Creative UI/UX design

如果你让人工智能来设计对于全新的用户界面或体验，人工智能并不擅长这种创造性的飞跃。它可以为已知模式（例如标准表单或仪表盘）生成 UI 代码，但如果您想要一个没有明确先例的创新 UI，人工智能可能无法提供令人眼前一亮的方案。它可能只是将熟悉的组件拼凑在一起。人类设计师和前端开发人员仍然非常需要构思全新的用户体验。从编码角度来看，人工智能可以快速生成一个标准的界面，但要获得那种独特的定制感，您需要引导它或进行手动调整。

If you ask AI to design a completely novel user interface or experience, it’s not great at that creative leap. It can generate UI code for known patterns (like a standard form or a dashboard), but if you want an innovative UI that doesn’t have clear precedents, the AI might not give you something inspiring. It might just stitch together familiar components. Human designers and frontend devs are still very much needed to dream up new user experiences. In coding terms, AI can make you a standard-looking interface quickly, but for that special custom feel, you’ll guide it or hand-tweak.

解读意图和要求

Interpreting intent and requirements

当需求不明确或相互矛盾时，人工智能有时会遇到困难。  除了你明确告知的指令之外，人工智能对最终目标并没有真正的理解。如果需求模糊不清（例如“提高效率”——这究竟是什么意思？），人工智能可能会错误地猜测你真正关心的是什么（例如，内存还是速度）。人类更擅长阐明意图，尤其是在与非技术利益相关者沟通时。人工智能也可能误解指令，特别是当它不了解特定领域的上下文信息（例如业务规则）时。它可能会生成一个逻辑上正确的解决方案，但由于理解上的细微差别而无法真正解决问题。

Sometimes AI struggles when requirements are implicit or contradictory.  It has no true understanding of the end goal beyond what you explicitly tell it. If requirements are vague (“make it efficient”—what does that precisely mean?), the AI might guess incorrectly what you care about (memory versus speed, for instance). Humans are better at clarifying intent, especially with nontechnical stakeholders. AI can also misinterpret instructions, especially if there’s domain-specific context it’s unaware of (like business rules). It might produce a logically correct solution that doesn’t actually solve the real problem because the nuance was lost in translation.

一个很好的结合这些概念的例子是：想象一下用 Rust 开发一个新的 3D 图形引擎（复杂系统）（系统级，性能至关重要）。你有一些全新的渲染算法（独特的问题）。人工智能或许可以帮你编写一些样板代码，但核心部分你主要还是要依靠人类的智慧。人工智能或许能帮你搭建一个窗口和一个基本的渲染循环（常见任务），但对于定制的部分，你仍然需要采用传统的严谨编码方式，或许可以从人工智能那里获得一些伪代码形式的算法帮助。如果你让它优化一个汇编语言的热点循环，你就必须逐条验证指令。

A good example scenario combining these: imagine developing a new 3D graphics engine (complex system) in Rust (system-level, performance critical). You have novel algorithms for rendering (unique problems). AI could maybe help write some boilerplate, but you’d largely rely on human ingenuity for the core. The AI might get you started with setting up a window and a basic render loop (common tasks), but for the bespoke parts, you’d proceed with traditional careful coding and perhaps get some algorithmic help from AI in pseudocode form. And if you asked it to optimize a hot loop in assembly, you’d have to verify every instruction.

人工智能也缺乏真正的解决问题的能力。归根结底，它只是在进行模式匹配。因此，如果你的问题需要灵光一闪的顿悟，人工智能可能只会徒劳无功，输出一些看起来像代码但实际上无法解决问题的东西。这时，人类退后一步，进行抽象思考，或者借鉴实际经验，就能力挽狂澜。一旦你有了顿悟，就可以利用人工智能快速将其付诸实践。

AI also lacks true problem-solving insight. At the end of the day, it’s pattern matching. So if your problem requires an aha! insight, the AI might just flail around, presenting things that look like code but don’t solve it. This is where a human stepping back, thinking abstractly, or drawing on real experience can save the day. Once you have the insight, you can then use the AI to implement it quickly.

了解这些优势和劣势，才能确保你在合适的场景下运用“氛围编码”技巧。为了最大限度地提高成功率，要充分利用人工智能的优势（已知模式），并将你的创造力应用于应用程序的独特部分。同时，也要做好准备，在人工智能表现不佳的领域进行干预。例如，仔细审查它编写的任何涉及安全敏感的代码，因为它可能会遗漏一两个极端情况。

Understanding these strengths and weaknesses ensures you’ll deploy vibe-coding techniques in the right situations. To maximize success, leverage the AI for what it’s good at (the known patterns), and apply your creativity to the unique parts of your application. Be ready to intervene in those areas where AI is known to struggle. For instance, do a careful review of any security-sensitive code it writes, because it might miss an edge case or two.

利用人工智能来补充人类的优势：让它处理广度较广的部分（大量代码、样板代码），而你则负责深度部分（复杂的逻辑、架构）。在它擅长的领域，把它当作助力；而在那些更具挑战性的路段，不要害怕亲自掌舵。这样可以充分发挥双方的优势，从而获得最佳结果。在这个新时代，懂得何时使用人工智能、何时依靠人类技能，才是成为一名高效开发者的关键。

Use AI to complement human strengths: let it handle breadth (lots of code, boilerplate) while you handle depth (complex logic, architecture). Use it as a booster where it excels, and don’t be afraid to take the wheel on those tougher stretches of the road. This plays to the strengths of both and yields the best outcome. Knowing when to use AI and when to rely on human skill is what will make you a highly effective developer in this new era.

每项新技术都有其优势和不足。当我们拥抱人工智能辅助开发带来的生产力和创造力提升时，以细致入微的方式对待它至关重要。了解其局限性和优缺点。主要优点包括：

Every new technology comes with its advantages and its caveats. As we embrace the productivity and creativity boost from AI-assisted development, it’s important to approach it with a nuanced understanding of its limitations and trade-offs. Key benefits include:

更快的开发周期

Faster development cycles

项目可以从概念阶段发展到原型更快地开发出最终产品。人工智能可以瞬间生成框架代码（例如为新项目设置样板代码），这样您就可以将更多时间用于应用程序的独特部分。

Projects can move from concept to prototype to finished product more quickly. AI can generate scaffolding code (like setting up the boilerplate for a new project) in a flash, so you spend more time on the unique parts of your application.

增强原型制作和实验

Enhanced prototyping and experimentation

因为尝试的成本较低（只需向人工智能描述你想要什么，就能得到一个快速草稿），所以开发者可能会更愿意进行实验。你可以通过不同的方式提示人工智能，从而测试解决问题的多种方法，然后选择最佳方案。这种迭代式的构思过程可以带来更具创意的解决方案。

Because the cost of trying something is lower (just describe what you want to the AI and get a quick draft), developers may feel freer to experiment. You can prototype multiple approaches to a problem by prompting the AI in different ways, then pick the best one. This iterative ideation can lead to more creative solutions.

知识触手可及

Knowledge at your fingertips

法学硕士（LLM）接受的是大量编程知识的培训。它通常“知道”一些晦涩难懂的API或错误信息解决方案。实际上，它可以提出你可能没想到的解决方案或思路，从而让你更有效地解决问题。

LLMs are trained on a vast corpus of programming knowledge. It often “knows” obscure APIs or error message solutions. In practice, it can surface solutions or ideas you might not have thought of, making you a more effective problem solver.

一致性和标准化

Consistency and standardization

在团队环境中，人工智能助手可以通过生成风格一致的代码来帮助执行编码标准和最佳实践。如果按照项目风格指南进行配置，它可以确保每个人的代码都遵循类似的模式。即使没有经过显式训练，AI 模型通常也能生成符合惯用语法的代码（因为它们从数百万个示例中学习而来）。这可以减少代码审查的工作量，因为其函数默认情况下看起来可能很熟悉，并且遵循常见的约定。

In team settings, an AI assistant can help enforce coding standards and best practices by generating code in a consistent style. If configured with your project’s style guide, it could ensure everyone’s code follows similar patterns. Even without explicit training, AI models often produce idiomatic code (since they learned from millions of examples). This can reduce the effort involved in code reviews, since its functions may look familiar and adhere to common conventions by default.

一些局限性需要考虑的权衡因素包括：

Some of the limitations and trade-offs to consider include:

产量质量不稳定

Variable output quality

这些模型并非完美无缺。它们生成的代码可能看起来正确，但存在一些不易察觉的错误或效率低下的问题。它们可能选择过时的方法，因为它们的训练数据中包含大量旧代码。作为开发者，你必须保持警惕。正如你不会在不理解代码的情况下从网上复制粘贴代码一样，你也不应该不加思考地接受人工智能生成的代码。本书第二部分将讨论如何全面验证和测试人工智能生成的代码。

These models are not infallible. They might produce code that looks correct but has subtle bugs or inefficiencies. They might choose an outdated approach because their training data included a lot of older code. As a developer, you must remain vigilant. Just as you wouldn’t copy-paste code from the internet without understanding it, you shouldn’t accept AI code thoughtlessly. Part II of this book will discuss techniques to validate and test AI-generated code thoroughly.

提示中的歧义会导致代码中的歧义。

Ambiguity in prompts leads to ambiguity in code

如果你的提示信息不够具体，人工智能就会……它必须猜测你的意图——而且它可能会猜错。例如，如果你告诉它“对姓名列表进行排序”，它可能默认按字母顺序排序，但也许你的意思是其他排序方式（例如按姓名长度排序）。除非你明确说明，否则人工智能无法区分。这就是为什么提示语的精确性（第二章的主题）至关重要——你将学会预判需要详细说明的内容。

If your prompt is underspecified, the AI has to guess your intent—and it might guess wrong. For example, if you tell it to “sort a list of names,” it might default to alphabetical sorting, but maybe you meant something else (like sorting by the length of the name). The AI won’t know the difference unless you clarify it. This is why specificity in prompts (Chapter 2’s topic) is vital—you’ll learn to anticipate what details you need to spell out.

过度依赖和技能退化

Overreliance and skill atrophy

如果新开发者总是依赖于人工智能写作他们的代码，能否培养出对算法和调试同样深刻的理解？这存在技能退化的风险，就像依赖GPS导航可能会削弱你的方向感一样。为了避免这种情况，重要的是将人工智能作为学习工具（注意它提供的代码并思考其原因），并且有时需要不借助人工智能进行编程练习，以确保你保持基本技能。

If new developers always rely on AI to write their code, will they develop the same depth of understanding of algorithms and debugging? There’s a risk of skill atrophy, similar to how relying on GPS for navigation might weaken your own sense of direction. To mitigate this, it’s important to use AI as a learning tool (pay attention to the code it provides and ask why) and sometimes practice coding without it to ensure you retain your fundamental skills.

隐私和安全问题

Privacy and security concerns

使用基于云的技术使用人工智能编码工具通常意味着将您的代码（可能包含专有信息或敏感信息）发送给第三方服务进行分析。企业需要考虑这一点。许多工具通过允许本地部署模型或保证不存储代码来解决这个问题，但这仍然是一个需要考虑的因素。此外，人工智能还可能无意中生成与其训练数据中某些内容非常相似的代码，而这些训练数据可能采用开源许可（例如 GPL）。虽然这种情况不太可能发生（而且已有措施防止出现完全相同的输出），但这凸显了在集成人工智能之前审查和理解其生成内容的重要性。第八章将深入探讨安全性和可靠性问题。

Using cloud-based AI coding tools often means sending your code (which might be proprietary or sensitive) to a third-party service for analysis. Companies need to consider this. Many tools are addressing it by allowing on-premises models or giving assurances about not storing code, but it’s still a consideration. Also, there’s a risk that AI might inadvertently generate code that is very similar to something in its training data, which could be under an open source license (like GPL). While unlikely (and measures are in place to prevent verbatim long outputs), it highlights the need to review and understand what the AI produces before integrating it. Chapter 8 dives into questions of security and reliability.

人工智能输出中的偏差

Bias in AI output

人工智能模型会反映出训练数据中存在的偏差。在编码环境中，这可能只是偏好某些变量名，也可能很严重，例如使用假设特定用户属性的示例。例如，它可能foo/bar对所有示例变量都使用相同的名称（因为很多示例都这样做了），或者它可能对用户区域设置做出假设。与其他人工智能应用相比，这在代码生成中通常不是什么大问题，但了解这种可能性仍然值得。更微妙的是，人工智能可能会倾向于选择它更常看到的解决方案，即使这些方案并非最适合你的情况。第九章将讨论偏见和其他伦理方面的考量。

AI models can reflect biases present in their training data. In a coding context, this might be as benign as preferring certain variable names or as significant as using examples that assume particular user attributes. For instance, it might use foo/bar for every example variable (because many examples did), or it might assume things about user locales. It’s usually not a huge issue in code generation compared to other AI applications, but it’s worth being aware of this possibility. More subtly, the AI might be biased toward solutions it saw more often, even if those aren’t the best for your case. Chapter 9 discusses bias and other ethical considerations.

人为因素和信任

Human factors and trust

并非所有开发者都能立即适应这种工作方式。编码本身就蕴含着某种乐趣和艺术性，而人工智能的介入可能会削弱这种乐趣和艺术性。此外，最初可能还会出现信任危机——“它真的做对了吗？”——而这只有通过良好的实践和时间的积累才能克服。采用人工智能的团队应该允许一段时间的适应，并鼓励经验和技巧的分享。随着时间的推移，就像任何工具一样，大多数团队最终会找到一种平衡点，既能重视人工智能的贡献，又能让人类的专业知识专注于他们最擅长的领域。

Not all developers are immediately comfortable with this style of work. Coding has a certain pleasure and artistry to it, and some may feel that is diminished by AI involvement. There can also be an initial lack of trust—“Did it really do this right?”—which only good practices and time can overcome. Teams adopting AI should allow a period of adjustment and encourage sharing of experiences and tips. Over time, as with any tool, most will find a balance where the AI’s contributions are valued and human expertise focuses on what humans do best.